@donotuse/eas-cli 18.5.0-rc.1

package/build/worker/deployment.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSignedDeploymentUrlAsync = getSignedDeploymentUrlAsync;
+exports.assignDevDomainNameAsync = assignDevDomainNameAsync;
+exports.assignWorkerDeploymentAliasAsync = assignWorkerDeploymentAliasAsync;
+exports.assignWorkerDeploymentProductionAsync = assignWorkerDeploymentProductionAsync;
+exports.selectWorkerDeploymentOnAppAsync = selectWorkerDeploymentOnAppAsync;
+exports.deleteWorkerDeploymentAliasAsync = deleteWorkerDeploymentAliasAsync;
+exports.selectWorkerDeploymentAliasOnAppAsync = selectWorkerDeploymentAliasOnAppAsync;
+exports.deleteWorkerDeploymentAsync = deleteWorkerDeploymentAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const mutations_1 = require("./mutations");
+const queries_1 = require("./queries");
+const logs_1 = require("./utils/logs");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+const memoize_1 = require("../utils/expodash/memoize");
+const relay_1 = require("../utils/relay");
+async function getSignedDeploymentUrlAsync(graphqlClient, options) {
+    try {
+        return await mutations_1.DeploymentsMutation.createSignedDeploymentUrlAsync(graphqlClient, {
+            appId: options.appId,
+            deploymentIdentifier: options.deploymentIdentifier,
+        });
+    }
+    catch (error) {
+        const isMissingDevDomain = error?.graphQLErrors?.some(e => ['APP_NO_DEV_DOMAIN_NAME'].includes(e?.extensions?.errorCode));
+        // Throw unexpected errors eagerly
+        if (!isMissingDevDomain) {
+            throw error;
+        }
+        // Ensure the callback is invoked, containing cleanup logic for possible spinners
+        options.onSetupDevDomain?.();
+        // Assign the dev domain name by prompting the user
+        await assignDevDomainNameAsync({
+            graphqlClient,
+            appId: options.appId,
+            nonInteractive: options.nonInteractive,
+        });
+        // Retry creating the signed URL
+        return await getSignedDeploymentUrlAsync(graphqlClient, options);
+    }
+}
+const DEV_DOMAIN_INVALID_START_END_CHARACTERS = /^[^a-z0-9]+|[^a-z0-9-]+$/;
+const DEV_DOMAIN_INVALID_REPLACEMENT_HYPHEN = /[^a-z0-9-]+/;
+const DEV_DOMAIN_INVALID_MULTIPLE_HYPHENS = /(-{2,})/;
+/**
+ * Format a dev domain name to match whats allowed on the backend.
+ * This is equal to our `DEV_DOMAIN_NAME_REGEX`, but implemented as a filtering function
+ * to help users find a valid name while typing.
+ */
+function formatDevDomainName(name = '') {
+    return name
+        .toLowerCase()
+        .replace(DEV_DOMAIN_INVALID_REPLACEMENT_HYPHEN, '-')
+        .replace(DEV_DOMAIN_INVALID_START_END_CHARACTERS, '')
+        .replace(DEV_DOMAIN_INVALID_MULTIPLE_HYPHENS, '-')
+        .trim();
+}
+async function promptDevDomainNameAsync(initialDevDomain) {
+    const rootDomain = `.${logs_1.EXPO_BASE_DOMAIN}.app`;
+    const memoizedFormatDevDomainName = (0, memoize_1.memoize)(formatDevDomainName);
+    const { name } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'name',
+        message: 'Choose a preview URL for your project:',
+        initial: initialDevDomain,
+        validate: (value) => {
+            if (!value) {
+                return 'You have to choose a preview URL for your project';
+            }
+            if (value.length < 3) {
+                return 'Preview URLs must be at least 3 characters long';
+            }
+            if (value.endsWith('-')) {
+                return 'Preview URLs cannot end with a hyphen (-)';
+            }
+            return true;
+        },
+        onState(state) {
+            const value = memoizedFormatDevDomainName(state.value);
+            if (value !== state.value) {
+                this.value = value;
+            }
+        },
+        onRender(kleur) {
+            this.cursorOffset = -rootDomain.length - 1;
+            if (this.done) {
+                // Remove the space for the cursor when the prompt is done
+                this.rendered = this.value + kleur.dim(`${rootDomain}`);
+            }
+            else if (this.placeholder) {
+                this.rendered = kleur.dim(`${this.initial} ${rootDomain}`);
+            }
+            else {
+                this.rendered = this.value + kleur.dim(` ${rootDomain}`);
+            }
+        },
+    });
+    // This should never happen due to the validation, if it does its an error
+    if (!name) {
+        throw new Error('No preview URL provided, aborting deployment.');
+    }
+    return name;
+}
+/**
+ * Assign a dev domain name to a project.
+ *   - When running in interactive mode, it will prompt the user with a suggested domain name.
+ *   - When running in non interactive mode, it will auto-assign the suggested domain name.
+ */
+async function assignDevDomainNameAsync({ graphqlClient, appId, nonInteractive, }) {
+    let devDomainName = await queries_1.DeploymentsQuery.getSuggestedDevDomainByAppIdAsync(graphqlClient, {
+        appId,
+    });
+    if (!nonInteractive) {
+        devDomainName = await promptDevDomainNameAsync(devDomainName);
+    }
+    try {
+        return await mutations_1.DeploymentsMutation.assignDevDomainNameAsync(graphqlClient, {
+            appId,
+            name: devDomainName,
+        });
+    }
+    catch (error) {
+        const isChosenNameTaken = error?.graphQLErrors?.some(e => ['DEV_DOMAIN_NAME_TAKEN'].includes(e?.extensions?.errorCode));
+        // Throw unexpected errors eagerly
+        if (!isChosenNameTaken) {
+            throw error;
+        }
+        if (!nonInteractive) {
+            log_1.default.error(`The preview URL "${devDomainName}" is already taken, choose a different URL.`);
+        }
+        return await assignDevDomainNameAsync({ graphqlClient, appId, nonInteractive });
+    }
+}
+async function assignWorkerDeploymentAliasAsync({ graphqlClient, appId, deploymentId, aliasName, }) {
+    return await mutations_1.DeploymentsMutation.assignAliasAsync(graphqlClient, {
+        appId,
+        deploymentId,
+        aliasName,
+    });
+}
+async function assignWorkerDeploymentProductionAsync({ graphqlClient, appId, deploymentId, }) {
+    return await mutations_1.DeploymentsMutation.assignAliasAsync(graphqlClient, {
+        appId,
+        deploymentId,
+        aliasName: null, // this will assign the deployment as production
+    });
+}
+async function selectWorkerDeploymentOnAppAsync({ graphqlClient, appId, selectTitle, pageSize, }) {
+    return await (0, relay_1.selectPaginatedAsync)({
+        pageSize: pageSize ?? 25,
+        printedType: selectTitle ?? 'worker deployment',
+        queryAsync: async (queryParams) => await queries_1.DeploymentsQuery.getAllDeploymentsPaginatedAsync(graphqlClient, {
+            ...queryParams,
+            appId,
+        }),
+        getTitleAsync: async (deployment) => (0, chalk_1.default) `${deployment.deploymentIdentifier}{dim  - created at: ${new Date(deployment.createdAt).toLocaleString()}}`,
+    });
+}
+async function deleteWorkerDeploymentAliasAsync({ graphqlClient, appId, aliasName, }) {
+    return await mutations_1.DeploymentsMutation.deleteAliasAsync(graphqlClient, {
+        appId,
+        aliasName,
+    });
+}
+async function selectWorkerDeploymentAliasOnAppAsync({ graphqlClient, appId, selectTitle, pageSize, }) {
+    return await (0, relay_1.selectPaginatedAsync)({
+        pageSize: pageSize ?? 25,
+        printedType: selectTitle ?? 'worker deployment alias',
+        queryAsync: async (queryParams) => await queries_1.DeploymentsQuery.getAllAliasesPaginatedAsync(graphqlClient, {
+            ...queryParams,
+            appId,
+        }),
+        getTitleAsync: async (alias) => (0, chalk_1.default) `${alias.aliasName ?? 'production'}{dim  - ${alias.url}}`,
+    });
+}
+async function deleteWorkerDeploymentAsync({ graphqlClient, appId, deploymentIdentifier, }) {
+    return await mutations_1.DeploymentsMutation.deleteWorkerDeploymentAsync(graphqlClient, {
+        appId,
+        deploymentIdentifier,
+    });
+}

package/build/worker/fragments/WorkerDeployment.d.ts

@@ -0,0 +1 @@
+export declare const WorkerDeploymentFragmentNode: import("graphql").DocumentNode;

package/build/worker/fragments/WorkerDeployment.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerDeploymentFragmentNode = void 0;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+exports.WorkerDeploymentFragmentNode = (0, graphql_tag_1.default) `
+  fragment WorkerDeploymentFragment on WorkerDeployment {
+    id
+    url
+    deploymentIdentifier
+    deploymentDomain
+    createdAt
+  }
+`;

package/build/worker/fragments/WorkerDeploymentAlias.d.ts

@@ -0,0 +1 @@
+export declare const WorkerDeploymentAliasFragmentNode: import("graphql").DocumentNode;

package/build/worker/fragments/WorkerDeploymentAlias.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerDeploymentAliasFragmentNode = void 0;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+exports.WorkerDeploymentAliasFragmentNode = (0, graphql_tag_1.default) `
+  fragment WorkerDeploymentAliasFragment on WorkerDeploymentAlias {
+    id
+    aliasName
+    url
+  }
+`;

package/build/worker/mutations.d.ts

@@ -0,0 +1,28 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AssignAliasMutation, DeleteAliasResult } from '../graphql/generated';
+export declare const DeploymentsMutation: {
+    createSignedDeploymentUrlAsync(graphqlClient: ExpoGraphqlClient, deploymentVariables: {
+        appId: string;
+        deploymentIdentifier?: string | null;
+    }): Promise<string>;
+    assignDevDomainNameAsync(graphqlClient: ExpoGraphqlClient, devDomainNameVariables: {
+        appId: string;
+        name: string;
+    }): Promise<boolean>;
+    assignAliasAsync(graphqlClient: ExpoGraphqlClient, aliasVariables: {
+        appId: string;
+        deploymentId: string;
+        aliasName: string | null;
+    }): Promise<AssignAliasMutation["deployments"]["assignAlias"]>;
+    deleteAliasAsync(graphqlClient: ExpoGraphqlClient, deleteAliasVariables: {
+        appId: string;
+        aliasName: string;
+    }): Promise<DeleteAliasResult>;
+    deleteWorkerDeploymentAsync(graphqlClient: ExpoGraphqlClient, deleteVariables: {
+        appId: string;
+        deploymentIdentifier: string;
+    }): Promise<{
+        deploymentIdentifier: string;
+        id: string;
+    }>;
+};

package/build/worker/mutations.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentsMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const WorkerDeployment_1 = require("./fragments/WorkerDeployment");
+const WorkerDeploymentAlias_1 = require("./fragments/WorkerDeploymentAlias");
+const client_1 = require("../graphql/client");
+exports.DeploymentsMutation = {
+    async createSignedDeploymentUrlAsync(graphqlClient, deploymentVariables) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation createDeploymentUrlMutation($appId: ID!, $deploymentIdentifier: ID) {
+              deployments {
+                createSignedDeploymentUrl(appId: $appId, deploymentIdentifier: $deploymentIdentifier) {
+                  pendingWorkerDeploymentId
+                  deploymentIdentifier
+                  url
+                }
+              }
+            }
+          `, deploymentVariables)
+            .toPromise());
+        const url = data.deployments?.createSignedDeploymentUrl.url;
+        (0, assert_1.default)(url, 'Deployment URL must be defined');
+        return url;
+    },
+    async assignDevDomainNameAsync(graphqlClient, devDomainNameVariables) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation AssignDevDomainName($appId: ID!, $name: DevDomainName!) {
+              devDomainName {
+                assignDevDomainName(appId: $appId, name: $name) {
+                  id
+                  name
+                }
+              }
+            }
+          `, devDomainNameVariables)
+            .toPromise());
+        return data.devDomainName.assignDevDomainName.name === devDomainNameVariables.name;
+    },
+    async assignAliasAsync(graphqlClient, aliasVariables) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation AssignAlias(
+              $appId: ID!
+              $deploymentId: ID!
+              $aliasName: WorkerDeploymentIdentifier
+            ) {
+              deployments {
+                assignAlias(
+                  appId: $appId
+                  deploymentIdentifier: $deploymentId
+                  aliasName: $aliasName
+                ) {
+                  id
+                  ...WorkerDeploymentAliasFragment
+                  workerDeployment {
+                    id
+                    ...WorkerDeploymentFragment
+                  }
+                }
+              }
+            }
+
+            ${(0, graphql_1.print)(WorkerDeployment_1.WorkerDeploymentFragmentNode)}
+            ${(0, graphql_1.print)(WorkerDeploymentAlias_1.WorkerDeploymentAliasFragmentNode)}
+          `, aliasVariables)
+            .toPromise());
+        return data.deployments.assignAlias;
+    },
+    async deleteAliasAsync(graphqlClient, deleteAliasVariables) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation DeleteAlias($appId: ID!, $aliasName: WorkerDeploymentIdentifier) {
+              deployments {
+                deleteAlias(appId: $appId, aliasName: $aliasName) {
+                  id
+                  aliasName
+                }
+              }
+            }
+          `, deleteAliasVariables)
+            .toPromise());
+        return data.deployments.deleteAlias;
+    },
+    async deleteWorkerDeploymentAsync(graphqlClient, deleteVariables) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation DeleteDeployment($appId: ID!, $deploymentIdentifier: ID!) {
+              deployments {
+                deleteWorkerDeploymentByIdentifier(appId: $appId, deploymentIdentifier: $deploymentIdentifier) {
+                  id
+                  deploymentIdentifier
+                }
+              }
+            }
+          `, deleteVariables)
+            .toPromise());
+        return data.deployments.deleteWorkerDeploymentByIdentifier;
+    },
+};

package/build/worker/queries.d.ts

@@ -0,0 +1,14 @@
+import type { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { type PaginatedWorkerDeploymentsQueryVariables, SuggestedDevDomainNameQueryVariables, type WorkerDeploymentAliasFragment, type WorkerDeploymentFragment } from '../graphql/generated';
+import type { Connection } from '../utils/relay';
+export declare const DeploymentsQuery: {
+    getAllDeploymentsPaginatedAsync(graphqlClient: ExpoGraphqlClient, { appId, first, after, last, before }: PaginatedWorkerDeploymentsQueryVariables): Promise<Connection<WorkerDeploymentFragment>>;
+    getSuggestedDevDomainByAppIdAsync(graphqlClient: ExpoGraphqlClient, { appId }: SuggestedDevDomainNameQueryVariables): Promise<string>;
+    getAllAliasesPaginatedAsync(graphqlClient: ExpoGraphqlClient, { appId, first, after, last, before, }: {
+        appId: string;
+        first?: number;
+        after?: string;
+        last?: number;
+        before?: string;
+    }): Promise<Connection<WorkerDeploymentAliasFragment>>;
+};

package/build/worker/queries.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentsQuery = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const WorkerDeployment_1 = require("./fragments/WorkerDeployment");
+const WorkerDeploymentAlias_1 = require("./fragments/WorkerDeploymentAlias");
+const client_1 = require("../graphql/client");
+exports.DeploymentsQuery = {
+    async getAllDeploymentsPaginatedAsync(graphqlClient, { appId, first, after, last, before }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query PaginatedWorkerDeployments(
+              $appId: String!
+              $first: Int
+              $after: String
+              $last: Int
+              $before: String
+            ) {
+              app {
+                byId(appId: $appId) {
+                  id
+                  workerDeployments(first: $first, after: $after, last: $last, before: $before) {
+                    pageInfo {
+                      hasNextPage
+                      hasPreviousPage
+                      startCursor
+                      endCursor
+                    }
+                    edges {
+                      cursor
+                      node {
+                        id
+                        ...WorkerDeploymentFragment
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            ${(0, graphql_1.print)(WorkerDeployment_1.WorkerDeploymentFragmentNode)}
+          `, { appId, first, after, last, before }, { additionalTypenames: ['WorkerDeployment'] })
+            .toPromise());
+        return data.app.byId.workerDeployments;
+    },
+    async getSuggestedDevDomainByAppIdAsync(graphqlClient, { appId }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query SuggestedDevDomainName($appId: String!) {
+              app {
+                byId(appId: $appId) {
+                  id
+                  suggestedDevDomainName
+                }
+              }
+            }
+          `, { appId }, { additionalTypenames: ['App'] })
+            .toPromise());
+        return data.app.byId.suggestedDevDomainName;
+    },
+    async getAllAliasesPaginatedAsync(graphqlClient, { appId, first, after, last, before, }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query PaginatedWorkerDeploymentAliases(
+              $appId: String!
+              $first: Int
+              $after: String
+              $last: Int
+              $before: String
+            ) {
+              app {
+                byId(appId: $appId) {
+                  id
+                  workerDeploymentAliases(
+                    first: $first
+                    after: $after
+                    last: $last
+                    before: $before
+                  ) {
+                    pageInfo {
+                      hasNextPage
+                      hasPreviousPage
+                      startCursor
+                      endCursor
+                    }
+                    edges {
+                      cursor
+                      node {
+                        id
+                        ...WorkerDeploymentAliasFragment
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            ${(0, graphql_1.print)(WorkerDeploymentAlias_1.WorkerDeploymentAliasFragmentNode)}
+          `, { appId, first, after, last, before }, { additionalTypenames: ['WorkerDeploymentAlias'] })
+            .toPromise());
+        return data.app.byId.workerDeploymentAliases;
+    },
+};

package/build/worker/upload.d.ts

@@ -0,0 +1,33 @@
+import { HeadersInit, RequestInit, Response } from 'node-fetch';
+import { AssetFileEntry } from './assets';
+export type UploadPayload = {
+    filePath: string;
+} | {
+    asset: AssetFileEntry;
+} | {
+    multipart: AssetFileEntry[];
+};
+export interface UploadRequestInit {
+    baseURL: string | URL;
+    method?: string;
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+}
+export interface UploadResult {
+    payload: UploadPayload;
+    response: Response;
+}
+type OnProgressUpdateCallback = (progress: number) => void;
+export declare function uploadAsync(init: UploadRequestInit, payload: UploadPayload, onProgressUpdate?: OnProgressUpdateCallback): Promise<UploadResult>;
+export declare function callUploadApiAsync(url: string | URL, init?: RequestInit): Promise<unknown>;
+export interface UploadPending {
+    payload: UploadPayload;
+    progress: number;
+}
+export declare function batchUploadAsync(init: UploadRequestInit, payloads: UploadPayload[], onProgressUpdate?: OnProgressUpdateCallback): AsyncGenerator<UploadPending>;
+interface UploadProgressBar {
+    update(progress: number): void;
+    stop(): void;
+}
+export declare function createProgressBar(label?: string): UploadProgressBar;
+export {};