@forge/cli 10.13.6 → 11.0.0

package/out/service/version-service.d.ts

@@ -0,0 +1,77 @@
+import { AppConfigProvider, AppEnvironmentType } from '@forge/cli-shared';
+import { AppVersionDetailsClient } from '../version/graphql-client';
+export interface VersionDetails {
+    appVersion: number;
+    deploymentDateTime: Date;
+    environmentType: AppEnvironmentType;
+    functions: {
+        key: string;
+        runtimeName: string;
+        handler: string;
+    }[];
+    modules: {
+        type: string;
+        items: {
+            key: string;
+            properties: any;
+        }[];
+    }[];
+    requiresLicense: boolean;
+    egresses: {
+        type: string;
+        addresses: string[];
+    }[];
+    scopes: string[];
+    policies: {
+        type: string;
+        policies: string[];
+    }[];
+    connectKeys: {
+        product: string;
+        key: string;
+    }[];
+    remotes: {
+        key: string;
+        baseUrl: string;
+        operations: string[];
+    }[];
+}
+export interface VersionOverview {
+    version: number;
+    deploymentDateTime: Date;
+    environmentType: AppEnvironmentType;
+    egresses: {
+        type: string;
+        count: number;
+    }[];
+    policies: {
+        type: string;
+        count: number;
+    }[];
+    scopes: string;
+    connectKeys: string;
+    functions: string;
+    remotes: string;
+    modules: {
+        type: string;
+        count: number;
+    }[];
+    requiresLicense: boolean;
+}
+export declare class VersionService {
+    private readonly getAppConfig;
+    private readonly versionDetailsClient;
+    constructor(getAppConfig: AppConfigProvider, versionDetailsClient: AppVersionDetailsClient);
+    private filterOutEmpty;
+    private getEgresses;
+    private getPolicies;
+    private getConnectedKeys;
+    private getFunctions;
+    getAppVersionDetails(environmentKey: string, majorVersion?: number): Promise<VersionDetails>;
+    private getTypeFromPermissionType;
+    private getModulesGroupedByTypes;
+    private removeInternalPropertiesFromObject;
+    private getAppVersions;
+    getAppVersionOverviewList(environmentKey: string): Promise<VersionOverview[]>;
+}
+//# sourceMappingURL=version-service.d.ts.map

package/out/service/version-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-service.d.ts","sourceRoot":"","sources":["../../src/service/version-service.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAOnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAGpE,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,IAAI,CAAC;IACzB,eAAe,EAAE,kBAAkB,CAAC;IACpC,SAAS,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACnE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,GAAG,CAAA;SAAE,EAAE,CAAA;KAAE,EAAE,CAAC;IACvE,eAAe,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IAClD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACjD,WAAW,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAChD,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;CACnE;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,EAAE,IAAI,CAAC;IACzB,eAAe,EAAE,kBAAkB,CAAC;IACpC,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,EAAE,CAAC;IACJ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,EAAE,CAAC;IACJ,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,EAAE,CAAC;IACJ,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,qBAAa,cAAc;IAEvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,oBAAoB;gBADpB,YAAY,EAAE,iBAAiB,EAC/B,oBAAoB,EAAE,uBAAuB;IAGhE,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,WAAW;IA4BnB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,YAAY;IAmDP,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IA4BzG,OAAO,CAAC,yBAAyB;IAajC,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,kCAAkC;YAM5B,cAAc;IAKf,yBAAyB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;CAsB3F"}

package/out/service/version-service.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionService = void 0;
+const semver_1 = require("semver");
+const cli_shared_1 = require("@forge/cli-shared");
+const manifest_1 = require("@forge/manifest");
+class VersionService {
+    getAppConfig;
+    versionDetailsClient;
+    constructor(getAppConfig, versionDetailsClient) {
+        this.getAppConfig = getAppConfig;
+        this.versionDetailsClient = versionDetailsClient;
+    }
+    filterOutEmpty(array) {
+        return array?.filter((entry) => entry !== null) || [];
+    }
+    getEgresses(egresses, remoteModules) {
+        const remoteModuleUrls = this.filterOutEmpty(remoteModules).map((remote) => remote?.extensionData.baseUrl);
+        const egressesWithoutRemoteModules = this.filterOutEmpty(egresses).map((entry) => {
+            if (entry.type === 'FETCH_BACKEND_SIDE') {
+                return {
+                    ...entry,
+                    addresses: entry.addresses?.filter((address) => !remoteModuleUrls.includes(address))
+                };
+            }
+            return entry;
+        });
+        return egressesWithoutRemoteModules
+            .filter((entry) => this.filterOutEmpty(entry.addresses).length !== 0)
+            .map((entry) => ({
+            type: this.getTypeFromPermissionType(entry.type),
+            addresses: entry.addresses || []
+        }));
+    }
+    getPolicies(securityPolicies) {
+        return this.filterOutEmpty(securityPolicies).map((entry) => ({
+            type: this.getTypeFromPermissionType(entry.type),
+            policies: entry.policies || []
+        }));
+    }
+    getConnectedKeys(migrationKeys) {
+        if (!migrationKeys) {
+            return [];
+        }
+        return Object.keys(migrationKeys).map((key) => ({
+            product: key,
+            key: migrationKeys[key] || ''
+        }));
+    }
+    getFunctions(functionModules) {
+        const isOldFunctionsExtension = (extensionData) => {
+            return 'functionName' in extensionData;
+        };
+        const isNewFunctionsExtension = (extensionData) => {
+            return 'functions' in extensionData;
+        };
+        const getRuntimeName = (identifier) => (identifier || 'sandbox').replace('provided.al2', 'sandbox').replace('provided', 'sandbox');
+        return this.filterOutEmpty(functionModules).map((entry) => {
+            const { key, extensionData } = entry;
+            if (isOldFunctionsExtension(extensionData)) {
+                return {
+                    key,
+                    runtimeName: getRuntimeName(extensionData.runtime?.identifier),
+                    handler: extensionData.handler
+                };
+            }
+            else if (isNewFunctionsExtension(extensionData)) {
+                const keysOfFunctions = Object.keys(extensionData.functions || {});
+                return {
+                    key,
+                    runtimeName: getRuntimeName(extensionData.functions[keysOfFunctions[0]].runtime.identifier),
+                    handler: extensionData.handler
+                };
+            }
+            else {
+                throw new Error('Unknown function extension data format');
+            }
+        });
+    }
+    async getAppVersionDetails(environmentKey, majorVersion) {
+        const { id: appId } = await this.getAppConfig();
+        const data = await this.versionDetailsClient.getVersionDetails(appId, environmentKey, majorVersion);
+        const functionModules = data.modules?.filter((mod) => mod?.extensionData.type === manifest_1.AllModuleTypes.CoreFunction);
+        const remoteModules = data.modules?.filter((mod) => mod?.extensionData.type === manifest_1.AllModuleTypes.CoreRemote);
+        const allModules = this.getModulesGroupedByTypes(data.modules);
+        return {
+            requiresLicense: data.requiresLicense,
+            egresses: this.getEgresses(data.permissions?.[0].egress, remoteModules),
+            scopes: data.permissions?.[0].scopes.map((scope) => scope.key).sort() || [],
+            policies: this.getPolicies(data.permissions?.[0].securityPolicies),
+            connectKeys: this.getConnectedKeys(data.migrationKeys),
+            appVersion: (0, semver_1.major)(data.appVersion),
+            deploymentDateTime: data.deploymentDateTime,
+            environmentType: data.environmentType,
+            functions: this.getFunctions(functionModules),
+            modules: Object.keys(allModules)
+                .filter((type) => !['function', 'remote'].includes(type))
+                .map((type) => ({ type, items: allModules[type] })),
+            remotes: this.filterOutEmpty(remoteModules).map((entry) => ({
+                key: entry.key || 'N/A',
+                baseUrl: entry.extensionData.baseUrl,
+                operations: entry.extensionData.operations || []
+            }))
+        };
+    }
+    getTypeFromPermissionType(permissionType) {
+        switch (permissionType) {
+            case cli_shared_1.AppNetworkPermissionType.FetchBackendSide:
+                return 'fetch.backend';
+            case cli_shared_1.AppNetworkPermissionType.FetchClientSide:
+                return 'fetch.client';
+            default:
+                return permissionType?.toLowerCase().replaceAll('_', '.') || 'N/A';
+        }
+    }
+    getModulesGroupedByTypes(modules) {
+        const rawModules = this.filterOutEmpty(modules)
+            .filter((mod) => manifest_1.SUPPORTED_MODULES.includes(mod.extensionData.type))
+            .filter((mod) => ![manifest_1.AllModuleTypes.CoreFunction, manifest_1.AllModuleTypes.CoreRemote].includes(mod.extensionData.type))
+            .map((entry) => ({
+            key: entry.key,
+            type: entry.extensionData.type,
+            properties: {
+                ...this.removeInternalPropertiesFromObject(entry.extensionData)
+            }
+        }));
+        return rawModules.reduce((acc, entry) => {
+            const type = (0, manifest_1.cleanKey)(entry.type);
+            if (acc[type] === undefined) {
+                acc[type] = [];
+            }
+            acc[type].push(entry);
+            return acc;
+        }, {});
+    }
+    removeInternalPropertiesFromObject(obj) {
+        const { type, functions, outboundAuthContainerId, resourceUploadId, key, ...rest } = obj;
+        return rest;
+    }
+    async getAppVersions(environmentKey) {
+        const { id: appId } = await this.getAppConfig();
+        return await this.versionDetailsClient.getVersionList(appId, environmentKey);
+    }
+    async getAppVersionOverviewList(environmentKey) {
+        const versions = await this.getAppVersions(environmentKey);
+        const majorVersions = versions.map((version) => (0, semver_1.major)(version)).filter((majorVersion) => majorVersion > 0);
+        const versionDetails = await Promise.all(majorVersions.map(async (version) => await this.getAppVersionDetails(environmentKey, version)));
+        return versionDetails.map((entry) => ({
+            version: entry.appVersion,
+            deploymentDateTime: entry.deploymentDateTime,
+            environmentType: entry.environmentType,
+            egresses: entry.egresses.map((egress) => ({ type: egress.type, count: egress.addresses.length })),
+            policies: entry.policies.map((policy) => ({ type: policy.type, count: policy.policies.length })),
+            scopes: (entry.scopes.length || 0).toString(),
+            connectKeys: (entry.connectKeys.length || 0).toString(),
+            functions: (entry.functions.length || 0).toString(),
+            remotes: (entry.remotes.length || 0).toString(),
+            modules: entry.modules.map((module) => ({ type: module.type, count: module.items.length })),
+            requiresLicense: entry.requiresLicense
+        }));
+    }
+}
+exports.VersionService = VersionService;

package/out/version/graphql-client.d.ts

@@ -0,0 +1,25 @@
+import { AppEnvironmentType, AppPermission, AppVersionExtension, GraphQLClient, Maybe, MigrationKeys, Storage, UserError } from '@forge/cli-shared';
+export interface AppVersionDetailsData {
+    migrationKeys?: Maybe<MigrationKeys> | null;
+    permissions?: Array<AppPermission> | null;
+    modules: Array<AppVersionExtension | null> | null | undefined;
+    environmentType: AppEnvironmentType;
+    appVersion: string;
+    deploymentDateTime: Date;
+    requiresLicense: boolean;
+    storage: Storage;
+}
+export declare class MissingAppError extends UserError {
+}
+export declare class EnvironmentNotFoundError extends UserError {
+    constructor(environmentKey: string);
+}
+export declare class MissingAppVersionError extends Error {
+}
+export declare class AppVersionDetailsClient {
+    private readonly graphqlClient;
+    constructor(graphqlClient: GraphQLClient);
+    getVersionDetails(appId: string, environmentKey: string, majorVersion?: number): Promise<AppVersionDetailsData>;
+    getVersionList(appId: string, environmentKey: string): Promise<string[]>;
+}
+//# sourceMappingURL=graphql-client.d.ts.map

package/out/version/graphql-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-client.d.ts","sourceRoot":"","sources":["../../src/version/graphql-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,KAAK,EACL,aAAa,EAEb,OAAO,EAEP,SAAS,EACV,MAAM,mBAAmB,CAAC;AAS3B,MAAM,WAAW,qBAAqB;IACpC,aAAa,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC5C,WAAW,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC1C,OAAO,EAAE,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IAC9D,eAAe,EAAE,kBAAkB,CAAC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,IAAI,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,qBAAa,eAAgB,SAAQ,SAAS;CAAG;AAEjD,qBAAa,wBAAyB,SAAQ,SAAS;gBACzC,cAAc,EAAE,MAAM;CAGnC;AAED,qBAAa,sBAAuB,SAAQ,KAAK;CAAG;AAEpD,qBAAa,uBAAuB;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAE5C,iBAAiB,CAC5B,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EACtB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,qBAAqB,CAAC;IAqFpB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAuDtF"}

package/out/version/graphql-client.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppVersionDetailsClient = exports.MissingAppVersionError = exports.EnvironmentNotFoundError = exports.MissingAppError = void 0;
+const cli_shared_1 = require("@forge/cli-shared");
+class MissingAppError extends cli_shared_1.UserError {
+}
+exports.MissingAppError = MissingAppError;
+class EnvironmentNotFoundError extends cli_shared_1.UserError {
+    constructor(environmentKey) {
+        super(cli_shared_1.Text.env.error.envNotExist(environmentKey));
+    }
+}
+exports.EnvironmentNotFoundError = EnvironmentNotFoundError;
+class MissingAppVersionError extends Error {
+}
+exports.MissingAppVersionError = MissingAppVersionError;
+class AppVersionDetailsClient {
+    graphqlClient;
+    constructor(graphqlClient) {
+        this.graphqlClient = graphqlClient;
+    }
+    async getVersionDetails(appId, environmentKey, majorVersion) {
+        const query = `
+      query forge_cli_getApplicationVersionDetails($appId: ID!, $environmentKey: String!, $firstN: Int!, $majorVersion: Int) {
+        app(id: $appId) {
+          environmentByKey(key: $environmentKey) {
+            type
+            versions(first: $firstN, majorVersion: $majorVersion) {
+              nodes {
+                version
+                createdAt
+                isLatest
+                requiresLicense
+                permissions {
+                  scopes {
+                    key
+                  }
+                  egress {
+                    type
+                    addresses
+                  }
+                  securityPolicies {
+                    type
+                    policies
+                  }
+                }
+                extensions {
+                  nodes {
+                    id
+                    key
+                    extensionData
+                  }
+                }
+                storage {
+                  hosted {
+                    classifications
+                    locations
+                  }
+                  remotes {
+                    key
+                    baseUrl
+                    classifications
+                    locations
+                  }
+                }
+                migrationKeys {
+                  jira
+                  confluence
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        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 MissingAppVersionError();
+        }
+        return {
+            migrationKeys: result.app.environmentByKey.versions?.nodes?.[0]?.migrationKeys,
+            environmentType: result.app.environmentByKey.type,
+            appVersion: result.app.environmentByKey.versions?.nodes?.[0]?.version,
+            deploymentDateTime: new Date(Number.parseInt(result.app.environmentByKey.versions?.nodes?.[0]?.createdAt)),
+            storage: result.app.environmentByKey.versions?.nodes?.[0]?.storage,
+            requiresLicense: result.app.environmentByKey.versions?.nodes?.[0]?.requiresLicense,
+            permissions: result.app.environmentByKey.versions?.nodes?.[0]?.permissions,
+            modules: result.app.environmentByKey.versions?.nodes?.[0]?.extensions?.nodes
+        };
+    }
+    async getVersionList(appId, environmentKey) {
+        const query = `
+      query forge_cli_getApplicationVersionList($appId: ID!, $first: Int, $after: String) {
+        app(id: $appId) {
+          environments {
+            key
+            versions(first: $first, after: $after) {
+              nodes {
+                version
+              }
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+            }
+          }
+        }
+      }
+    `;
+        const output = [];
+        let cursor = undefined;
+        let hasNext = undefined;
+        do {
+            const result = await this.graphqlClient.query(query, {
+                appId,
+                first: 20,
+                after: cursor
+            });
+            if (!result.app) {
+                throw new MissingAppError();
+            }
+            if (!result.app.environments) {
+                throw new MissingAppVersionError();
+            }
+            const environment = result.app.environments.filter((env) => env.key === environmentKey)[0];
+            cursor = environment?.versions?.pageInfo.endCursor;
+            hasNext = environment?.versions?.pageInfo.hasNextPage;
+            output.push(...(environment?.versions?.nodes?.map((node) => node?.version) || []).filter((item) => Boolean(item)));
+        } while (hasNext && cursor);
+        return output;
+    }
+}
+exports.AppVersionDetailsClient = AppVersionDetailsClient;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@forge/cli",
-  "version": "10.13.6",
+  "version": "11.0.0",
   "description": "A command line interface for managing Atlassian-hosted apps",
   "author": "Atlassian",
-  "license": "UNLICENSED",
+  "license": "SEE LICENSE IN LICENSE.txt",
   "bin": {
     "forge": "out/bin/cli.js"
   },
@@ -18,16 +18,16 @@
     "postinstall": "node -e \"fs.existsSync('./out/bin/postinstall.js') && require('./out/bin/postinstall.js')\""
   },
   "dependencies": {
-    "@forge/bundler": "4.20.7",
-    "@forge/cli-shared": "6.5.4",
-    "@forge/egress": "1.3.0",
-    "@forge/lint": "5.6.7",
-    "@forge/manifest": "8.6.0",
-    "@forge/runtime": "5.10.4",
-    "@forge/tunnel": "5.9.1",
-    "@forge/util": "1.4.6",
+    "@forge/bundler": "4.20.8",
+    "@forge/cli-shared": "6.6.0",
+    "@forge/egress": "1.3.1",
+    "@forge/lint": "5.7.0",
+    "@forge/manifest": "8.6.1",
+    "@forge/runtime": "5.10.5",
+    "@forge/tunnel": "5.9.2",
+    "@forge/util": "1.4.7",
     "@sentry/node": "7.106.0",
-    "@forge/i18n": "0.0.2",
+    "@forge/i18n": "0.0.3",
     "ajv": "^8.12.0",
     "archiver": "^6.0.2",
     "case": "^1.6.3",
@@ -39,6 +39,7 @@
     "cross-spawn": "^7.0.3",
     "dayjs": "^1.11.10",
     "didyoumean": "^1.2.2",
+    "diff": "^7.0.0",
     "env-paths": "^2.2.1",
     "exponential-backoff": "^3.1.1",
     "form-data": "^4.0.0",
@@ -63,6 +64,7 @@
     "@types/command-exists": "^1.2.3",
     "@types/cross-spawn": "^6.0.6",
     "@types/didyoumean": "^1.2.2",
+    "@types/diff": "^6.0.0",
     "@types/fs-extra": "^11.0.4",
     "@types/hidefile": "^3.0.3",
     "@types/inquirer": "^8.2.10",

package/out/installations/site-translation/cloudid-products.d.ts

@@ -1,25 +0,0 @@
-/// <reference types="node" />
-import { SiteTranslator } from './site-translation';
-import { URL } from 'url';
-import { Ari } from '@forge/util/packages/ari';
-import { GraphQLClient, UserError, EnrichedAri } from '@forge/cli-shared';
-export declare class InvalidAtlassianSiteError extends UserError {
-    constructor(url: URL);
-}
-declare type CloudIdAndActivationId = {
-    cloudId: string;
-    activationId: string;
-};
-export declare class ActivationIdMissingError extends Error {
-    constructor(url: string, product: string);
-}
-export declare class CloudIdTranslator implements SiteTranslator {
-    private graphqlClient;
-    constructor(graphqlClient: GraphQLClient);
-    ariBelongsToProduct(ari: EnrichedAri): boolean;
-    buildInstallationContext(product: string, site: URL): Promise<Ari>;
-    getSitesForResourceAris(aris: EnrichedAri[]): Promise<Record<string, string>>;
-    getCloudIdAndActivationId(site: URL, product: string): Promise<CloudIdAndActivationId>;
-}
-export {};
-//# sourceMappingURL=cloudid-products.d.ts.map

package/out/installations/site-translation/cloudid-products.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cloudid-products.d.ts","sourceRoot":"","sources":["../../../src/installations/site-translation/cloudid-products.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAC1B,OAAO,EAAE,GAAG,EAAE,MAAM,0BAA0B,CAAC;AAC/C,OAAO,EACL,aAAa,EAOb,SAAS,EAET,WAAW,EAEZ,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,yBAA0B,SAAQ,SAAS;gBAC1C,GAAG,EAAE,GAAG;CAGrB;AAED,aAAK,sBAAsB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AACxE,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAGzC;AA+BD,qBAAa,iBAAkB,YAAW,cAAc;IAC1C,OAAO,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAEzC,mBAAmB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO;IAQxC,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IASlE,uBAAuB,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IA2C7E,yBAAyB,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;CAsBpG"}

package/out/installations/site-translation/cloudid-products.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudIdTranslator = exports.ActivationIdMissingError = exports.InvalidAtlassianSiteError = void 0;
-const cli_shared_1 = require("@forge/cli-shared");
-class InvalidAtlassianSiteError extends cli_shared_1.UserError {
-    constructor(url) {
-        super(cli_shared_1.Text.install.error.invalidAtlassianSite(url));
-    }
-}
-exports.InvalidAtlassianSiteError = InvalidAtlassianSiteError;
-class ActivationIdMissingError extends Error {
-    constructor(url, product) {
-        super(cli_shared_1.Text.install.error.activationIdMissing(url, product));
-    }
-}
-exports.ActivationIdMissingError = ActivationIdMissingError;
-const tenantContextsToCloudIdAndActivationId = (url, contexts, product) => {
-    if (!contexts.length) {
-        throw new InvalidAtlassianSiteError(url);
-    }
-    const context = contexts[0];
-    if (!context || !context.cloudId) {
-        throw new InvalidAtlassianSiteError(url);
-    }
-    const activationId = context.activationIdByProduct?.active;
-    if (!activationId) {
-        throw new ActivationIdMissingError(url.toString(), product);
-    }
-    return { cloudId: context.cloudId, activationId: activationId };
-};
-const tenantToHostname = (tenantInfo) => {
-    if (!tenantInfo) {
-        return null;
-    }
-    return tenantInfo.hostName || null;
-};
-class CloudIdTranslator {
-    graphqlClient;
-    constructor(graphqlClient) {
-        this.graphqlClient = graphqlClient;
-    }
-    ariBelongsToProduct(ari) {
-        return (ari.resourceType === cli_shared_1.SITE_RESOURCE_TYPE ||
-            (ari.resourceType === cli_shared_1.WORKSPACE_RESOURCE_TYPE &&
-                ![cli_shared_1.TRELLO_RESOURCE_OWNER, cli_shared_1.BITBUCKET_RESOURCE_OWNER].includes(ari.resourceOwner)));
-    }
-    async buildInstallationContext(product, site) {
-        const lowerCaseProduct = product.toLowerCase();
-        const { cloudId, activationId } = await this.getCloudIdAndActivationId(site, lowerCaseProduct);
-        const workspaceAriCreator = cli_shared_1.createWorkspaceAriByProduct[lowerCaseProduct];
-        const workspaceAri = workspaceAriCreator(cloudId, activationId);
-        return workspaceAri;
-    }
-    async getSitesForResourceAris(aris) {
-        const MAX_CLOUD_IDS_AT_ONCE = 20;
-        const cloudIds = [...new Set(aris.map((ari) => ari.derivedCloudId))];
-        const cloudIdsChunks = [];
-        for (let i = 0; i < cloudIds.length; i += MAX_CLOUD_IDS_AT_ONCE) {
-            cloudIdsChunks.push(cloudIds.slice(i, i + MAX_CLOUD_IDS_AT_ONCE));
-        }
-        const query = `
-        query forge_cli_getHostnameForTenantContexts($cloudIds: [ID!]!) {
-            tenantContexts(cloudIds: $cloudIds) {
-            hostName
-            }
-        }
-        `;
-        const results = await Promise.all(cloudIdsChunks.map((cloudIdsChunk) => this.graphqlClient.query(query, {
-            cloudIds: cloudIdsChunk
-        })));
-        const tenantContexts = [].concat(...results.map((result) => result.tenantContexts || []));
-        const cloudIdToHostname = {};
-        const ariToHostname = {};
-        cloudIds.forEach((cloudId, index) => {
-            const maybeHostname = tenantToHostname(tenantContexts[index]);
-            cloudIdToHostname[cloudId] = maybeHostname || cloudId;
-        });
-        aris.forEach((ari) => {
-            ariToHostname[ari.toString()] = cloudIdToHostname[ari.derivedCloudId];
-        });
-        return ariToHostname;
-    }
-    async getCloudIdAndActivationId(site, product) {
-        const query = `
-        query getTenantContextDetails($hostNames: [String!], $product: String!) {
-          tenantContexts(hostNames: $hostNames) {
-            cloudId
-            activationIdByProduct(product: $product) {
-              product
-              active
-            }
-          }
-        }
-        `;
-        const result = await this.graphqlClient.query(query, {
-            hostNames: [site.hostname],
-            product
-        });
-        const tenantContexts = result.tenantContexts || [];
-        return tenantContextsToCloudIdAndActivationId(site, tenantContexts, product);
-    }
-}
-exports.CloudIdTranslator = CloudIdTranslator;