npm package diff

Package: @forge/cli

Versions: 11.3.1 - 11.4.0-next.1-experimental-01f8230

File: package/out/version/graphql-client.js

Index: package/out/version/graphql-client.js
===================================================================
--- package/out/version/graphql-client.js
+++ package/out/version/graphql-client.js
@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppVersionDetailsClient = exports.MissingAppVersionError = exports.EnvironmentNotFoundError = exports.MissingAppError = void 0;
+exports.AppVersionDetailsClient = exports.MissingAppVersionError = exports.EnvironmentNotFoundError = exports.MissingAppVersionRolloutError = exports.MissingAppError = void 0;
 const cli_shared_1 = require("@forge/cli-shared");
 class MissingAppError extends cli_shared_1.UserError {
 }
 exports.MissingAppError = MissingAppError;
+class MissingAppVersionRolloutError extends Error {
+}
+exports.MissingAppVersionRolloutError = MissingAppVersionRolloutError;
 class EnvironmentNotFoundError extends cli_shared_1.UserError {
     constructor(environmentKey) {
         super(cli_shared_1.Text.env.error.envNotExist(environmentKey));
     }
@@ -141,6 +144,208 @@
             output.push(...(environment?.versions?.nodes?.map((node) => node?.version) || []).filter((item) => Boolean(item)));
         } while (hasNext && cursor);
         return output;
     }
+    async getAppUpgradeVersionsList(appId, environmentKey) {
+        const query = `
+      query forge_cli_getAppUpgradeVersionsList($appId: ID!, $environmentKey: String!) {
+        app(id: $appId) {
+          environmentByKey(key: $environmentKey) {
+            key
+            versions {
+              nodes {
+                createdAt
+                id
+                installations {
+                  totalCount
+                }
+                version
+              }
+            }
+          }
+        }
+      }
+    `;
+        let output = [];
+        const result = await this.graphqlClient.query(query, {
+            appId,
+            environmentKey
+        });
+        if (!result.app) {
+            throw new MissingAppError();
+        }
+        if (!result.app.environmentByKey || !result.app.environmentByKey.versions) {
+            throw new MissingAppVersionError();
+        }
+        const versions = result.app.environmentByKey.versions.nodes;
+        if (!versions || versions.length === 0) {
+            return output;
+        }
+        output = versions.map((node) => {
+            return {
+                version: node?.version ?? '',
+                installations: node?.installations?.totalCount ?? 0,
+                deploymentDateTime: node?.createdAt ? new Date(Number.parseInt(node?.createdAt)) : undefined,
+                id: node?.id ?? ''
+            };
+        });
+        return output;
+    }
+    async getAppUpgradableToList(appId, environmentKey, sourceVersionId) {
+        const query = `
+      query forge_cli_getAppUpgradableToList($appId: ID!, $environmentKey: String!, $sourceVersionId: ID!) {
+        app(id: $appId) {
+          environmentByKey(key: $environmentKey) {
+            key
+            versions {
+              nodes {
+                createdAt
+                id
+                version
+                upgradeableByRolloutFromVersion(
+                  sourceVersionId: $sourceVersionId
+                ) {
+                  upgradeableByRollout
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        let output = [];
+        const result = await this.graphqlClient.query(query, {
+            appId,
+            environmentKey,
+            sourceVersionId
+        });
+        if (!result.app) {
+            throw new MissingAppError();
+        }
+        if (!result.app.environmentByKey || !result.app.environmentByKey.versions) {
+            throw new MissingAppVersionError();
+        }
+        const versions = result.app.environmentByKey.versions.nodes;
+        if (!versions || versions.length === 0) {
+            return output;
+        }
+        output = versions.map((node) => {
+            return {
+                version: node?.version ?? '',
+                deploymentDateTime: node?.createdAt ? new Date(Number.parseInt(node?.createdAt)) : undefined,
+                id: node?.id ?? '',
+                upgradeableTo: node?.upgradeableByRolloutFromVersion?.upgradeableByRollout
+            };
+        });
+        return output.filter((version) => version.upgradeableTo);
+    }
+    async createAppVersionUpgradeRollout(environmentKey, sourceVersionId, targetVersionId) {
+        const query = `
+      mutation forge_cli_createAppVersionUpgradeRollout($input: CreateAppVersionRolloutInput!) {
+        ecosystem {
+          createAppVersionRollout(input: $input) {
+            success
+            appVersionRollout {
+              id
+              status
+            }
+            errors {
+              message
+              extensions {
+                errorType
+                statusCode
+              }
+            }
+          }
+        }
+      }
+    `;
+        const variables = {
+            input: {
+                sourceVersionId,
+                targetVersionId
+            }
+        };
+        const { response: { ecosystem: { createAppVersionRollout } }, requestId } = await this.graphqlClient.mutate(query, variables);
+        if (!createAppVersionRollout) {
+            throw new cli_shared_1.GraphQlMutationError(`Unable to get a response (requestId: ${requestId || 'unknown'})`, { requestId });
+        }
+        const { success, appVersionRollout, errors } = createAppVersionRollout;
+        if (success) {
+            if (!appVersionRollout) {
+                throw new MissingAppVersionRolloutError();
+            }
+            return appVersionRollout.id;
+        }
+        else {
+            if (errors && errors.length > 0) {
+                const errorList = [];
+                errors.forEach((error) => {
+                    if (error?.extensions?.errorType && error.message) {
+                        switch (error.extensions.errorType) {
+                            case 'APP_ROLLOUT_RUNNING':
+                                errorList.push(cli_shared_1.Text.version.upgrade.error.appVersionRolloutRunning);
+                                break;
+                            case 'PermissionDeniedError':
+                                errorList.push(cli_shared_1.Text.version.upgrade.error.permissionDeniedError(sourceVersionId, targetVersionId, environmentKey));
+                                break;
+                            case 'APP_NOT_FOUND':
+                                errorList.push(cli_shared_1.Text.version.upgrade.error.inValidVersionNumberSpecified(sourceVersionId, targetVersionId));
+                                break;
+                            case 'TOO_MANY_APP_ROLLOUTS_RUNNING_FOR_ACCOUNT':
+                                errorList.push(cli_shared_1.Text.version.upgrade.error.tooManyRequestsFromAccount);
+                                break;
+                            case 'APP_ROLLOUTS_UNAVAILABLE':
+                                errorList.push(cli_shared_1.Text.version.upgrade.error.tooManyRequestsGlobally);
+                                break;
+                            default:
+                                errorList.push(error.message);
+                                break;
+                        }
+                    }
+                    else {
+                        errorList.push(error?.message ? error.message : '');
+                    }
+                });
+                throw new Error(errorList.join(`\n`));
+            }
+        }
+    }
+    async getAppVersionIdentity(appId, environmentKey, majorVersion) {
+        const query = `
+      query forge_cli_getApplicationIdentityVersionDetails($appId: ID!, $environmentKey: String!, $firstN: Int!, $majorVersion: Int) {
+        app(id: $appId) {
+          environmentByKey(key: $environmentKey) {
+            type
+            versions(first: $firstN, majorVersion: $majorVersion) {
+              nodes {
+                version
+                id
+              }
+            }
+          }
+        }
+      }
+    `;
+        const result = await this.graphqlClient.query(query, {
+            appId,
+            environmentKey,
+            firstN: 1,
+            majorVersion
+        });
+        if (!result.app) {
+            throw new MissingAppError();
+        }
+        if (!result.app.environmentByKey) {
+            throw new EnvironmentNotFoundError(environmentKey);
+        }
+        if (!result.app.environmentByKey.versions?.nodes?.length || !result.app.environmentByKey.versions?.nodes?.[0]) {
+            throw new Error(cli_shared_1.Text.version.upgrade.error.inValidMajorVersionNumberSpecified(majorVersion));
+        }
+        return {
+            id: result.app.environmentByKey.versions?.nodes?.[0]?.id,
+            appVersion: result.app.environmentByKey.versions?.nodes?.[0]?.version
+        };
+    }
 }
 exports.AppVersionDetailsClient = AppVersionDetailsClient;
+//# sourceMappingURL=graphql-client.js.map
\ No newline at end of file