eas-cli 12.0.0 → 12.1.1

package/build/worker/deployment.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSignedDeploymentUrlAsync = void 0;
+const tslib_1 = require("tslib");
+const mutations_1 = require("./mutations");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+async function getSignedDeploymentUrlAsync(graphqlClient, exp, deploymentVariables) {
+    try {
+        return await mutations_1.DeploymentsMutation.createSignedDeploymentUrlAsync(graphqlClient, deploymentVariables);
+    }
+    catch (error) {
+        const isMissingDevDomain = error?.graphQLErrors?.some(e => ['APP_NO_DEV_DOMAIN_NAME'].includes(e?.extensions?.errorCode));
+        if (!isMissingDevDomain) {
+            throw error;
+        }
+        await chooseDevDomainNameAsync({
+            graphqlClient,
+            appId: deploymentVariables.appId,
+            slug: exp.slug,
+        });
+        return await mutations_1.DeploymentsMutation.createSignedDeploymentUrlAsync(graphqlClient, deploymentVariables);
+    }
+}
+exports.getSignedDeploymentUrlAsync = getSignedDeploymentUrlAsync;
+async function chooseDevDomainNameAsync({ graphqlClient, appId, slug, }) {
+    const validationMessage = 'The project does not have a dev domain name.';
+    const { name } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'name',
+        message: 'Choose a dev domain name for your project:',
+        validate: value => (value && value.length > 3 ? true : validationMessage),
+        initial: slug,
+    });
+    if (!name) {
+        throw new Error('Prompt failed');
+    }
+    try {
+        const success = await mutations_1.DeploymentsMutation.assignDevDomainNameAsync(graphqlClient, {
+            appId,
+            name,
+        });
+        if (!success) {
+            throw new Error('Failed to assign dev domain name');
+        }
+    }
+    catch (error) {
+        const isChosenNameTaken = error?.graphQLErrors?.some(e => ['DEV_DOMAIN_NAME_TAKEN'].includes(e?.extensions?.errorCode));
+        if (isChosenNameTaken) {
+            log_1.default.error(`The entered dev domain name "${name}" is taken. Choose a different name.`);
+            await chooseDevDomainNameAsync({ graphqlClient, appId, slug });
+        }
+        if (!isChosenNameTaken) {
+            throw error;
+        }
+    }
+}

package/build/worker/mutations.d.ts

@@ -0,0 +1,11 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+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>;
+};

package/build/worker/mutations.js

@@ -0,0 +1,45 @@
+"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_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+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;
+    },
+};

package/build/worker/upload.d.ts

@@ -0,0 +1,20 @@
+import { HeadersInit, RequestInit, Response } from 'node-fetch';
+export interface UploadParams extends Omit<RequestInit, 'signal' | 'body'> {
+    filePath: string;
+    compress?: boolean;
+    url: string;
+    method?: string;
+    headers?: HeadersInit;
+    body?: undefined;
+    signal?: AbortSignal;
+}
+export interface UploadResult {
+    params: UploadParams;
+    response: Response;
+}
+export declare function uploadAsync(params: UploadParams): Promise<UploadResult>;
+export interface UploadPending {
+    params: UploadParams;
+}
+export type BatchUploadSignal = UploadResult | UploadPending;
+export declare function batchUploadAsync(uploads: readonly UploadParams[]): AsyncGenerator<BatchUploadSignal>;

package/build/worker/upload.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchUploadAsync = exports.uploadAsync = void 0;
+const tslib_1 = require("tslib");
+const https = tslib_1.__importStar(require("https"));
+const https_proxy_agent_1 = tslib_1.__importDefault(require("https-proxy-agent"));
+const mime_1 = tslib_1.__importDefault(require("mime"));
+const minizlib_1 = require("minizlib");
+const node_fetch_1 = tslib_1.__importStar(require("node-fetch"));
+const node_fs_1 = tslib_1.__importStar(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const promise_retry_1 = tslib_1.__importDefault(require("promise-retry"));
+const MAX_RETRIES = 4;
+const MAX_CONCURRENCY = 10;
+const MIN_RETRY_TIMEOUT = 100;
+const MAX_UPLOAD_SIZE = 5e8; // 5MB
+const MIN_COMPRESSION_SIZE = 5e4; // 50kB
+const isCompressible = (contentType, size) => {
+    if (size < MIN_COMPRESSION_SIZE) {
+        // Don't compress small files
+        return false;
+    }
+    else if (contentType && /^(?:audio|video|image)\//i.test(contentType)) {
+        // Never compress images, audio, or videos as they're presumably precompressed
+        return false;
+    }
+    else if (contentType && /^application\//i.test(contentType)) {
+        // Only compress `application/` files if they're marked as XML/JSON/JS
+        return /(?:xml|json5?|javascript)$/i.test(contentType);
+    }
+    else {
+        return true;
+    }
+};
+let sharedAgent;
+const getAgent = () => {
+    if (sharedAgent) {
+        return sharedAgent;
+    }
+    else if (process.env.https_proxy) {
+        return (sharedAgent = (0, https_proxy_agent_1.default)(process.env.https_proxy));
+    }
+    else {
+        return (sharedAgent = new https.Agent({
+            keepAlive: true,
+            maxSockets: MAX_CONCURRENCY,
+            maxTotalSockets: MAX_CONCURRENCY,
+            scheduling: 'lifo',
+            timeout: 4000,
+        }));
+    }
+};
+async function uploadAsync(params) {
+    const { filePath, signal, compress, method = 'POST', url, headers: headersInit, ...requestInit } = params;
+    const stat = await node_fs_1.default.promises.stat(params.filePath);
+    if (stat.size > MAX_UPLOAD_SIZE) {
+        throw new Error(`Upload of "${params.filePath}" aborted: File size is greater than the upload limit (>500MB)`);
+    }
+    const contentType = mime_1.default.getType(node_path_1.default.basename(params.filePath));
+    return await (0, promise_retry_1.default)(async (retry) => {
+        const headers = new node_fetch_1.Headers(headersInit);
+        if (contentType) {
+            headers.set('content-type', contentType);
+        }
+        let bodyStream = (0, node_fs_1.createReadStream)(filePath);
+        if (compress && isCompressible(contentType, stat.size)) {
+            const gzip = new minizlib_1.Gzip({ portable: true });
+            bodyStream.on('error', error => gzip.emit('error', error));
+            // @ts-expect-error: Gzip implements a Readable-like interface
+            bodyStream = bodyStream.pipe(gzip);
+            headers.set('content-encoding', 'gzip');
+        }
+        let response;
+        try {
+            response = await (0, node_fetch_1.default)(params.url, {
+                ...requestInit,
+                method,
+                body: bodyStream,
+                headers,
+                agent: getAgent(),
+                // @ts-expect-error: Internal types don't match
+                signal,
+            });
+        }
+        catch (error) {
+            return retry(error);
+        }
+        if (response.status === 408 ||
+            response.status === 409 ||
+            response.status === 429 ||
+            (response.status >= 500 && response.status <= 599)) {
+            const message = `Upload of "${filePath}" failed: ${response.statusText}`;
+            const text = await response.text().catch(() => null);
+            return retry(new Error(text ? `${message}\n${text}` : message));
+        }
+        else if (response.status === 413) {
+            const message = `Upload of "${filePath}" failed: File size exceeded the upload limit`;
+            throw new Error(message);
+        }
+        else if (!response.ok) {
+            throw new Error(`Upload of "${filePath}" failed: ${response.statusText}`);
+        }
+        return {
+            params,
+            response,
+        };
+    }, {
+        retries: MAX_RETRIES,
+        minTimeout: MIN_RETRY_TIMEOUT,
+        randomize: true,
+        factor: 2,
+    });
+}
+exports.uploadAsync = uploadAsync;
+async function* batchUploadAsync(uploads) {
+    const controller = new AbortController();
+    const queue = new Set();
+    try {
+        let index = 0;
+        while (index < uploads.length || queue.size > 0) {
+            while (queue.size < MAX_CONCURRENCY && index < uploads.length) {
+                const uploadParams = uploads[index++];
+                let uploadPromise;
+                queue.add((uploadPromise = uploadAsync({ ...uploadParams, signal: controller.signal }).finally(() => queue.delete(uploadPromise))));
+                yield { params: uploadParams };
+            }
+            yield await Promise.race(queue);
+        }
+    }
+    catch (error) {
+        if (typeof error !== 'object' || error.name !== 'AbortError') {
+            throw error;
+        }
+    }
+    finally {
+        if (queue.size > 0) {
+            controller.abort();
+        }
+    }
+}
+exports.batchUploadAsync = batchUploadAsync;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "12.0.0",
+  "version": "12.1.1",
   "commands": {
     "analytics": {
       "id": "analytics",
@@ -3378,6 +3378,27 @@
         "loggedIn": {}
       }
     },
+    "worker:deploy": {
+      "id": "worker:deploy",
+      "description": "deploy an Expo web build",
+      "strict": true,
+      "pluginName": "eas-cli",
+      "pluginAlias": "eas-cli",
+      "pluginType": "core",
+      "hidden": true,
+      "state": "beta",
+      "aliases": [
+        "deploy"
+      ],
+      "flags": {},
+      "args": {},
+      "contextDefinition": {
+        "getDynamicPublicProjectConfigAsync": {},
+        "getDynamicPrivateProjectConfigAsync": {},
+        "projectDir": {},
+        "loggedIn": {}
+      }
+    },
     "build:version:get": {
       "id": "build:version:get",
       "description": "get the latest version from EAS servers",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eas-cli",
   "description": "EAS command line tool",
-  "version": "12.0.0",
+  "version": "12.1.1",
   "author": "Expo <support@expo.dev>",
   "bin": {
     "eas": "./bin/run"
@@ -63,6 +63,7 @@
     "log-symbols": "4.1.0",
     "mime": "3.0.0",
     "minimatch": "5.1.2",
+    "minizlib": "3.0.1",
     "nanoid": "3.3.4",
     "node-fetch": "2.6.7",
     "node-forge": "1.3.1",
@@ -78,6 +79,7 @@
     "semver": "7.5.4",
     "slash": "3.0.0",
     "tar": "6.2.1",
+    "tar-stream": "3.1.7",
     "terminal-link": "2.1.1",
     "tslib": "2.6.2",
     "turndown": "7.1.2",
@@ -105,6 +107,7 @@
     "@types/prompts": "2.4.2",
     "@types/semver": "7.5.6",
     "@types/tar": "6.1.10",
+    "@types/tar-stream": "3.1.3",
     "@types/tough-cookie": "4.0.2",
     "@types/uuid": "9.0.7",
     "@types/wrap-ansi": "3.0.0",
@@ -223,5 +226,5 @@
     "node": "20.11.0",
     "yarn": "1.22.21"
   },
-  "gitHead": "50943f333ab40086f47b5bb711e73f18b4bf53c3"
+  "gitHead": "d63fc1f01ed170f17091ee391d0d9bc388a5fda9"
 }