eas-cli 16.14.0 → 16.15.0

package/build/commands/deploy/index.js

@@ -14,11 +14,11 @@ const log_1 = tslib_1.__importStar(require("../../log"));
 const ora_1 = require("../../ora");
 const projectUtils_1 = require("../../project/projectUtils");
 const json_1 = require("../../utils/json");
-const progress_1 = require("../../utils/progress");
 const WorkerAssets = tslib_1.__importStar(require("../../worker/assets"));
 const deployment_1 = require("../../worker/deployment");
 const upload_1 = require("../../worker/upload");
 const logs_1 = require("../../worker/utils/logs");
+const MAX_UPLOAD_SIZE = 5e8; // 500MB
 const isDirectory = (directoryPath) => node_fs_1.default.promises
     .stat(directoryPath)
     .then(stat => stat.isDirectory())
@@ -96,14 +96,11 @@ class WorkerDeploy extends EasCommand_1.default {
             }
         }
         async function uploadTarballAsync(tarPath, uploadUrl) {
+            const payload = { filePath: tarPath };
             const { response } = await (0, upload_1.uploadAsync)({
-                url: uploadUrl,
-                filePath: tarPath,
-                compress: false,
-                headers: {
-                    accept: 'application/json',
-                },
-            });
+                baseURL: uploadUrl,
+                method: 'POST',
+            }, payload);
             if (response.status === 413) {
                 throw new Error('Upload failed! (Payload too large)\n' +
                     `The files in "${path.relative(projectDir, projectDist.path)}" (at: ${projectDir}) exceed the maximum file size (10MB gzip).`);
@@ -116,7 +113,7 @@ class WorkerDeploy extends EasCommand_1.default {
                 if (!json.success || !json.result || typeof json.result !== 'object') {
                     throw new Error(json.message ? `Upload failed: ${json.message}` : 'Upload failed!');
                 }
-                const { id, fullName, token } = json.result;
+                const { id, fullName, token, upload } = json.result;
                 if (typeof token !== 'string') {
                     throw new Error('Upload failed: API failed to return a deployment token');
                 }
@@ -126,56 +123,57 @@ class WorkerDeploy extends EasCommand_1.default {
                 else if (typeof fullName !== 'string') {
                     throw new Error('Upload failed: API failed to return a script name');
                 }
+                else if (!Array.isArray(upload) && upload !== undefined) {
+                    throw new Error('Upload failed: API returned invalid asset upload instructions');
+                }
                 const baseURL = new URL('/', uploadUrl).toString();
-                return { id, fullName, baseURL, token };
+                return { id, fullName, baseURL, token, upload };
             }
         }
-        async function uploadAssetsAsync(assetMap, deployParams) {
-            const uploadParams = [];
-            const assetPath = projectDist.type === 'server' ? projectDist.clientPath : projectDist.path;
-            if (!assetPath) {
-                return;
+        async function uploadAssetsAsync(assetFiles, deployParams) {
+            const baseURL = new URL('/asset/', deployParams.baseURL);
+            const uploadInit = { baseURL, method: 'POST' };
+            uploadInit.baseURL.searchParams.set('token', deployParams.token);
+            const uploadPayloads = [];
+            if (deployParams.upload) {
+                const assetsBySHA512 = assetFiles.reduce((map, asset) => {
+                    map.set(asset.sha512, asset);
+                    return map;
+                }, new Map());
+                const payloads = deployParams.upload
+                    .map(instruction => instruction.sha512.map(sha512 => {
+                    const asset = assetsBySHA512.get(sha512);
+                    if (!asset) {
+                        // NOTE(@kitten): This should never happen
+                        throw new Error(`Uploading assets failed: API instructed us to upload an asset that does not exist`);
+                    }
+                    return asset;
+                }))
+                    .filter(assets => assets && assets.length > 0)
+                    .map(assets => (assets.length > 1 ? { multipart: assets } : { asset: assets[0] }));
+                uploadPayloads.push(...payloads);
             }
-            for await (const asset of WorkerAssets.listAssetMapFilesAsync(assetPath, assetMap)) {
-                const uploadURL = new URL(`/asset/${asset.sha512}`, deployParams.baseURL);
-                uploadURL.searchParams.set('token', deployParams.token);
-                uploadParams.push({ url: uploadURL.toString(), filePath: asset.path });
+            else {
+                // NOTE(@kitten): Legacy format which uploads assets one-by-one
+                uploadPayloads.push(...assetFiles.map(asset => ({ asset })));
             }
-            const progress = {
-                total: uploadParams.length,
-                pending: 0,
-                percent: 0,
-                transferred: 0,
-            };
-            const updateProgress = (0, progress_1.createProgressTracker)({
-                total: progress.total,
-                message(ratio) {
-                    const percent = `${Math.floor(ratio * 100)}`;
-                    const details = chalk_1.default.dim(`(${progress.pending} Pending, ${progress.transferred} Completed, ${progress.total} Total)`);
-                    return `Uploading assets: ${percent.padStart(3)}% ${details}`;
-                },
-                completedMessage: 'Uploaded assets',
-            });
+            const progressTotal = uploadPayloads.reduce((acc, payload) => acc + ('multipart' in payload ? payload.multipart.length : 1), 0);
+            const progressTracker = (0, upload_1.createProgressBar)(`Uploading ${progressTotal} assets`);
             try {
-                for await (const signal of (0, upload_1.batchUploadAsync)(uploadParams)) {
-                    if ('response' in signal) {
-                        progress.pending--;
-                        progress.percent = ++progress.transferred / progress.total;
-                    }
-                    else {
-                        progress.pending++;
-                    }
-                    updateProgress({ progress });
+                for await (const signal of (0, upload_1.batchUploadAsync)(uploadInit, uploadPayloads, progressTracker.update)) {
+                    progressTracker.update(signal.progress);
                 }
             }
             catch (error) {
-                updateProgress({ isComplete: true, error });
+                progressTracker.stop();
                 throw error;
             }
-            updateProgress({ isComplete: true });
+            finally {
+                progressTracker.stop();
+            }
         }
-        let assetMap;
         let tarPath;
+        let assetFiles;
         let deployResult;
         let progress = (0, ora_1.ora)('Preparing project').start();
         try {
@@ -189,9 +187,9 @@ class WorkerDeploy extends EasCommand_1.default {
                     'In case of conflict, the EAS environment variable values will be used: ' +
                     manifestResult.conflictingVariableNames.join(' '));
             }
-            assetMap = await WorkerAssets.createAssetMapAsync(projectDist.type === 'server' ? projectDist.clientPath : projectDist.path);
+            assetFiles = await WorkerAssets.collectAssetsAsync(projectDist.type === 'server' ? projectDist.clientPath : projectDist.path, { maxFileSize: MAX_UPLOAD_SIZE });
             tarPath = await WorkerAssets.packFilesIterableAsync(emitWorkerTarballAsync({
-                assetMap,
+                assetMap: WorkerAssets.assetsToAssetsMap(assetFiles),
                 manifest: manifestResult.manifest,
             }));
             if (flags.dryRun) {
@@ -232,7 +230,7 @@ class WorkerDeploy extends EasCommand_1.default {
             }
             throw error;
         }
-        await uploadAssetsAsync(assetMap, deployResult);
+        await uploadAssetsAsync(assetFiles, deployResult);
         await finalizeDeployAsync(deployResult);
         let deploymentAlias = null;
         if (flags.aliasName) {

package/build/credentials/ios/actions/AppleTeamUtils.js

@@ -5,7 +5,7 @@ async function resolveAppleTeamIfAuthenticatedAsync(ctx, app) {
     if (!ctx.appStore.authCtx) {
         return null;
     }
-    return await ctx.ios.createOrGetExistingAppleTeamAsync(ctx.graphqlClient, app.account, {
+    return await ctx.ios.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(ctx.graphqlClient, app.account.id, {
         appleTeamIdentifier: ctx.appStore.authCtx.team.id,
         appleTeamName: ctx.appStore.authCtx.team.name,
     });

package/build/credentials/ios/actions/SetUpTargetBuildCredentialsFromCredentialsJson.js

@@ -26,7 +26,7 @@ class SetUpTargetBuildCredentialsFromCredentialsJson {
         const appInfo = `@${this.app.account.name}/${this.app.projectName} (${this.app.bundleIdentifier})`;
         // new credentials from local json
         const appleTeamFromProvisioningProfile = (0, provisioningProfile_1.readAppleTeam)(this.targetCredentials.provisioningProfile);
-        const appleTeam = await ctx.ios.createOrGetExistingAppleTeamAsync(ctx.graphqlClient, this.app.account, {
+        const appleTeam = await ctx.ios.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(ctx.graphqlClient, this.app.account.id, {
             appleTeamIdentifier: appleTeamFromProvisioningProfile.teamId,
             appleTeamName: appleTeamFromProvisioningProfile.teamName,
         });

package/build/credentials/ios/api/GraphqlClient.d.ts

@@ -24,7 +24,7 @@ export declare function updateIosAppCredentialsAsync(graphqlClient: ExpoGraphqlC
     applePushKeyId?: string;
     ascApiKeyIdForSubmissions?: string;
 }): Promise<CommonIosAppCredentialsFragment>;
-export declare function createOrGetExistingAppleTeamAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment, { appleTeamIdentifier, appleTeamName }: {
+export declare function createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient: ExpoGraphqlClient, accountId: string, { appleTeamIdentifier, appleTeamName }: {
     appleTeamIdentifier: string;
     appleTeamName?: string;
 }): Promise<AppleTeamFragment>;

package/build/credentials/ios/api/GraphqlClient.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteAscApiKeyAsync = exports.getAscApiKeyForAppSubmissionsAsync = exports.getAscApiKeysForAccountAsync = exports.createAscApiKeyAsync = exports.deletePushKeyAsync = exports.getPushKeyForAppAsync = exports.getPushKeysForAccountAsync = exports.createPushKeyAsync = exports.deleteDistributionCertificateAsync = exports.createDistributionCertificateAsync = exports.getDistributionCertificatesForAccountAsync = exports.getDistributionCertificateForAppAsync = exports.deleteProvisioningProfilesAsync = exports.updateProvisioningProfileAsync = exports.getProvisioningProfileAsync = exports.createProvisioningProfileAsync = exports.getDevicesForAppleTeamAsync = exports.createOrGetExistingAppleAppIdentifierAsync = exports.createOrGetExistingAppleTeamAsync = exports.updateIosAppCredentialsAsync = exports.createOrGetIosAppCredentialsWithCommonFieldsAsync = exports.getIosAppCredentialsWithCommonFieldsAsync = exports.getIosAppCredentialsWithBuildCredentialsAsync = exports.createOrUpdateIosAppBuildCredentialsAsync = void 0;
+exports.deleteAscApiKeyAsync = exports.getAscApiKeyForAppSubmissionsAsync = exports.getAscApiKeysForAccountAsync = exports.createAscApiKeyAsync = exports.deletePushKeyAsync = exports.getPushKeyForAppAsync = exports.getPushKeysForAccountAsync = exports.createPushKeyAsync = exports.deleteDistributionCertificateAsync = exports.createDistributionCertificateAsync = exports.getDistributionCertificatesForAccountAsync = exports.getDistributionCertificateForAppAsync = exports.deleteProvisioningProfilesAsync = exports.updateProvisioningProfileAsync = exports.getProvisioningProfileAsync = exports.createProvisioningProfileAsync = exports.getDevicesForAppleTeamAsync = exports.createOrGetExistingAppleAppIdentifierAsync = exports.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync = exports.updateIosAppCredentialsAsync = exports.createOrGetIosAppCredentialsWithCommonFieldsAsync = exports.getIosAppCredentialsWithCommonFieldsAsync = exports.getIosAppCredentialsWithBuildCredentialsAsync = exports.createOrUpdateIosAppBuildCredentialsAsync = void 0;
 const tslib_1 = require("tslib");
 const apple_utils_1 = require("@expo/apple-utils");
 const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
@@ -117,16 +117,22 @@ async function createOrGetExistingIosAppCredentialsWithBuildCredentialsAsync(gra
         }));
     }
 }
-async function createOrGetExistingAppleTeamAsync(graphqlClient, account, { appleTeamIdentifier, appleTeamName }) {
-    const appleTeam = await AppleTeamQuery_1.AppleTeamQuery.getByAppleTeamIdentifierAsync(graphqlClient, account.id, appleTeamIdentifier);
+async function createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient, accountId, { appleTeamIdentifier, appleTeamName }) {
+    const appleTeam = await AppleTeamQuery_1.AppleTeamQuery.getByAppleTeamIdentifierAsync(graphqlClient, accountId, appleTeamIdentifier);
     if (appleTeam) {
+        const didAppleTeamNameChange = appleTeamName && appleTeam && appleTeamName !== appleTeam.appleTeamName;
+        if (didAppleTeamNameChange) {
+            return await AppleTeamMutation_1.AppleTeamMutation.updateAppleTeamAsync(graphqlClient, {
+                appleTeamName,
+            }, appleTeam.id);
+        }
         return appleTeam;
     }
     else {
-        return await AppleTeamMutation_1.AppleTeamMutation.createAppleTeamAsync(graphqlClient, { appleTeamIdentifier, appleTeamName }, account.id);
+        return await AppleTeamMutation_1.AppleTeamMutation.createAppleTeamAsync(graphqlClient, { appleTeamIdentifier, appleTeamName }, accountId);
     }
 }
-exports.createOrGetExistingAppleTeamAsync = createOrGetExistingAppleTeamAsync;
+exports.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync = createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync;
 async function createOrGetExistingAppleAppIdentifierAsync(graphqlClient, { account, projectName, bundleIdentifier, parentBundleIdentifier }, appleTeam) {
     const appleAppIdentifier = await AppleAppIdentifierQuery_1.AppleAppIdentifierQuery.byBundleIdentifierAsync(graphqlClient, account.name, bundleIdentifier);
     if (appleAppIdentifier) {
@@ -188,7 +194,7 @@ async function getDistributionCertificatesForAccountAsync(graphqlClient, account
 }
 exports.getDistributionCertificatesForAccountAsync = getDistributionCertificatesForAccountAsync;
 async function createDistributionCertificateAsync(graphqlClient, account, distCert) {
-    const appleTeam = await createOrGetExistingAppleTeamAsync(graphqlClient, account, {
+    const appleTeam = await createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient, account.id, {
         appleTeamIdentifier: distCert.teamId,
         appleTeamName: distCert.teamName,
     });
@@ -206,7 +212,7 @@ async function deleteDistributionCertificateAsync(graphqlClient, distributionCer
 }
 exports.deleteDistributionCertificateAsync = deleteDistributionCertificateAsync;
 async function createPushKeyAsync(graphqlClient, account, pushKey) {
-    const appleTeam = await createOrGetExistingAppleTeamAsync(graphqlClient, account, {
+    const appleTeam = await createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient, account.id, {
         appleTeamIdentifier: pushKey.teamId,
         appleTeamName: pushKey.teamName,
     });
@@ -232,7 +238,7 @@ async function deletePushKeyAsync(graphqlClient, pushKeyId) {
 exports.deletePushKeyAsync = deletePushKeyAsync;
 async function createAscApiKeyAsync(graphqlClient, account, ascApiKey) {
     const maybeAppleTeam = ascApiKey.teamId
-        ? await createOrGetExistingAppleTeamAsync(graphqlClient, account, {
+        ? await createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient, account.id, {
             appleTeamIdentifier: ascApiKey.teamId,
             appleTeamName: ascApiKey.teamName,
         })

package/build/credentials/ios/api/graphql/mutations/AppleTeamMutation.d.ts

@@ -1,8 +1,6 @@
 import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
-import { AccountFragment, AppleTeamFragment, AppleTeamInput } from '../../../../../graphql/generated';
-export type AppleTeamMutationResult = AppleTeamFragment & {
-    account: AccountFragment;
-};
+import { AppleTeamFragment, AppleTeamInput, AppleTeamUpdateInput } from '../../../../../graphql/generated';
 export declare const AppleTeamMutation: {
-    createAppleTeamAsync(graphqlClient: ExpoGraphqlClient, appleTeamInput: AppleTeamInput, accountId: string): Promise<AppleTeamMutationResult>;
+    createAppleTeamAsync(graphqlClient: ExpoGraphqlClient, appleTeamInput: AppleTeamInput, accountId: string): Promise<AppleTeamFragment>;
+    updateAppleTeamAsync(graphqlClient: ExpoGraphqlClient, appleTeamInput: AppleTeamUpdateInput, appleTeamEntityId: string): Promise<AppleTeamFragment>;
 };

package/build/credentials/ios/api/graphql/mutations/AppleTeamMutation.js

@@ -5,7 +5,6 @@ const tslib_1 = require("tslib");
 const graphql_1 = require("graphql");
 const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../../../../../graphql/client");
-const Account_1 = require("../../../../../graphql/types/Account");
 const AppleTeam_1 = require("../../../../../graphql/types/credentials/AppleTeam");
 exports.AppleTeamMutation = {
     async createAppleTeamAsync(graphqlClient, appleTeamInput, accountId) {
@@ -16,15 +15,10 @@ exports.AppleTeamMutation = {
                 createAppleTeam(appleTeamInput: $appleTeamInput, accountId: $accountId) {
                   id
                   ...AppleTeamFragment
-                  account {
-                    id
-                    ...AccountFragment
-                  }
                 }
               }
             }
             ${(0, graphql_1.print)(AppleTeam_1.AppleTeamFragmentNode)}
-            ${(0, graphql_1.print)(Account_1.AccountFragmentNode)}
           `, {
             appleTeamInput,
             accountId,
@@ -32,4 +26,26 @@ exports.AppleTeamMutation = {
             .toPromise());
         return data.appleTeam.createAppleTeam;
     },
+    async updateAppleTeamAsync(graphqlClient, appleTeamInput, appleTeamEntityId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation UpdateAppleTeamMutation(
+              $appleTeamInput: AppleTeamUpdateInput!
+              $appleTeamEntityId: ID!
+            ) {
+              appleTeam {
+                updateAppleTeam(appleTeamUpdateInput: $appleTeamInput, id: $appleTeamEntityId) {
+                  id
+                  ...AppleTeamFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AppleTeam_1.AppleTeamFragmentNode)}
+          `, {
+            appleTeamInput,
+            appleTeamEntityId,
+        })
+            .toPromise());
+        return data.appleTeam.updateAppleTeam;
+    },
 };

package/build/devices/manager.js

@@ -5,8 +5,7 @@ const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const action_1 = tslib_1.__importDefault(require("./actions/create/action"));
-const AppleTeamMutation_1 = require("../credentials/ios/api/graphql/mutations/AppleTeamMutation");
-const AppleTeamQuery_1 = require("../credentials/ios/api/graphql/queries/AppleTeamQuery");
+const GraphqlClient_1 = require("../credentials/ios/api/GraphqlClient");
 const log_1 = tslib_1.__importDefault(require("../log"));
 const projectUtils_1 = require("../project/projectUtils");
 const prompts_1 = require("../prompts");
@@ -27,7 +26,7 @@ class DeviceManager {
         log_1.default.addNewLineIfNone();
         const account = await this.resolveAccountAsync();
         const appleAuthCtx = await this.ctx.appStore.ensureAuthenticatedAsync();
-        const appleTeam = await ensureAppleTeamExistsAsync(this.ctx.graphqlClient, account.id, {
+        const appleTeam = await (0, GraphqlClient_1.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync)(this.ctx.graphqlClient, account.id, {
             appleTeamIdentifier: appleAuthCtx.team.id,
             appleTeamName: appleAuthCtx.team.name,
         });
@@ -81,15 +80,3 @@ class AccountResolver {
     }
 }
 exports.AccountResolver = AccountResolver;
-async function ensureAppleTeamExistsAsync(graphqlClient, accountId, { appleTeamIdentifier, appleTeamName }) {
-    const appleTeam = await AppleTeamQuery_1.AppleTeamQuery.getByAppleTeamIdentifierAsync(graphqlClient, accountId, appleTeamIdentifier);
-    if (appleTeam) {
-        return appleTeam;
-    }
-    else {
-        return await AppleTeamMutation_1.AppleTeamMutation.createAppleTeamAsync(graphqlClient, {
-            appleTeamIdentifier,
-            appleTeamName,
-        }, accountId);
-    }
-}

package/build/graphql/generated.d.ts

@@ -9004,34 +9004,22 @@ export type CreateAppleTeamMutation = {
             id: string;
             appleTeamIdentifier: string;
             appleTeamName?: string | null;
-            account: {
-                __typename?: 'Account';
-                id: string;
-                name: string;
-                ownerUserActor?: {
-                    __typename?: 'SSOUser';
-                    id: string;
-                    username: string;
-                } | {
-                    __typename?: 'User';
-                    id: string;
-                    username: string;
-                } | null;
-                users: Array<{
-                    __typename?: 'UserPermission';
-                    role: Role;
-                    actor: {
-                        __typename?: 'Robot';
-                        id: string;
-                    } | {
-                        __typename?: 'SSOUser';
-                        id: string;
-                    } | {
-                        __typename?: 'User';
-                        id: string;
-                    };
-                }>;
-            };
+        };
+    };
+};
+export type UpdateAppleTeamMutationVariables = Exact<{
+    appleTeamInput: AppleTeamUpdateInput;
+    appleTeamEntityId: Scalars['ID']['input'];
+}>;
+export type UpdateAppleTeamMutation = {
+    __typename?: 'RootMutation';
+    appleTeam: {
+        __typename?: 'AppleTeamMutation';
+        updateAppleTeam: {
+            __typename?: 'AppleTeam';
+            id: string;
+            appleTeamIdentifier: string;
+            appleTeamName?: string | null;
         };
     };
 };

package/build/worker/assets.d.ts

@@ -6,11 +6,24 @@ import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGr
 import { EnvironmentVariableEnvironment } from '../graphql/generated';
 interface AssetMapOptions {
     hashOptions?: HashOptions;
+    maxFileSize: number;
 }
+export interface AssetFileEntry {
+    normalizedPath: string;
+    path: string;
+    size: number;
+    sha512: string;
+    type: string | null;
+}
+/** Collects assets from a given target path */
+export declare function collectAssetsAsync(assetPath: string | undefined, options: AssetMapOptions): Promise<AssetFileEntry[]>;
 /** Mapping of normalized file paths to a SHA512 hash */
-export type AssetMap = Record<string, string>;
-/** Creates an asset map of a given target path */
-declare function createAssetMapAsync(assetPath?: string, options?: AssetMapOptions): Promise<AssetMap>;
+export type AssetMap = Record<string, string | {
+    sha512: string;
+    size: number;
+}>;
+/** Converts array of asset entries into AssetMap (as sent to deployment-api) */
+export declare function assetsToAssetsMap(assets: AssetFileEntry[]): AssetMap;
 export interface Manifest {
     env: Record<string, string | undefined>;
 }
@@ -31,16 +44,9 @@ interface WorkerFileEntry {
     data: Buffer | string;
 }
 /** Reads worker files while normalizing sourcemaps and providing normalized paths */
-declare function listWorkerFilesAsync(workerPath: string): AsyncGenerator<WorkerFileEntry>;
-interface AssetFileEntry {
-    normalizedPath: string;
-    sha512: string;
-    path: string;
-}
-/** Reads files of an asset maps and enumerates normalized paths and data */
-declare function listAssetMapFilesAsync(assetPath: string, assetMap: AssetMap): AsyncGenerator<AssetFileEntry>;
+export declare function listWorkerFilesAsync(workerPath: string): AsyncGenerator<WorkerFileEntry>;
 /** Entry of a normalized (gzip-safe) path and file data */
 export type FileEntry = readonly [normalizedPath: string, data: Buffer | string];
 /** Packs file entries into a tar.gz file (path to tgz returned) */
-declare function packFilesIterableAsync(iterable: Iterable<FileEntry> | AsyncIterable<FileEntry>, options?: GzipOptions): Promise<string>;
-export { createAssetMapAsync, listWorkerFilesAsync, listAssetMapFilesAsync, packFilesIterableAsync, };
+export declare function packFilesIterableAsync(iterable: Iterable<FileEntry> | AsyncIterable<FileEntry>, options?: GzipOptions): Promise<string>;
+export {};

package/build/worker/assets.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.packFilesIterableAsync = exports.listAssetMapFilesAsync = exports.listWorkerFilesAsync = exports.createAssetMapAsync = exports.createManifestAsync = void 0;
+exports.packFilesIterableAsync = exports.listWorkerFilesAsync = exports.createManifestAsync = exports.assetsToAssetsMap = exports.collectAssetsAsync = void 0;
 const tslib_1 = require("tslib");
 const env_1 = require("@expo/env");
+const mime_1 = tslib_1.__importDefault(require("mime"));
 const minizlib_1 = require("minizlib");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = tslib_1.__importStar(require("node:fs"));
@@ -50,9 +51,12 @@ function listFilesRecursively(basePath) {
                 continue;
             }
             else if (dirent.isFile()) {
+                const absolutePath = node_path_1.default.resolve(target, dirent.name);
+                const stats = await node_fs_1.default.promises.stat(absolutePath);
                 yield {
                     normalizedPath,
-                    path: node_path_1.default.resolve(target, dirent.name),
+                    path: absolutePath,
+                    size: stats.size,
                 };
             }
             else if (dirent.isDirectory()) {
@@ -62,17 +66,54 @@ function listFilesRecursively(basePath) {
     }
     return recurseAsync();
 }
-/** Creates an asset map of a given target path */
-async function createAssetMapAsync(assetPath, options) {
-    const map = Object.create(null);
+async function determineMimeTypeAsync(filePath) {
+    let contentType = mime_1.default.getType(node_path_1.default.basename(filePath));
+    if (!contentType) {
+        const fileContent = await node_fs_1.default.promises.readFile(filePath, 'utf-8');
+        try {
+            // check if file is valid JSON without an extension, e.g. for the apple app site association file
+            const parsedData = JSON.parse(fileContent);
+            if (parsedData) {
+                contentType = 'application/json';
+            }
+        }
+        catch { }
+    }
+    return contentType;
+}
+/** Collects assets from a given target path */
+async function collectAssetsAsync(assetPath, options) {
+    const assets = [];
     if (assetPath) {
         for await (const file of listFilesRecursively(assetPath)) {
-            map[file.normalizedPath] = await computeSha512HashAsync(file.path, options?.hashOptions);
+            if (file.size > options.maxFileSize) {
+                throw new Error(`Upload of "${file.normalizedPath}" aborted: File size is greater than the upload limit (>500MB)`);
+            }
+            const sha512$ = computeSha512HashAsync(file.path, options?.hashOptions);
+            const contentType$ = determineMimeTypeAsync(file.path);
+            assets.push({
+                normalizedPath: file.normalizedPath,
+                path: file.path,
+                size: file.size,
+                sha512: await sha512$,
+                type: await contentType$,
+            });
         }
     }
-    return map;
+    return assets;
 }
-exports.createAssetMapAsync = createAssetMapAsync;
+exports.collectAssetsAsync = collectAssetsAsync;
+/** Converts array of asset entries into AssetMap (as sent to deployment-api) */
+function assetsToAssetsMap(assets) {
+    return assets.reduce((map, entry) => {
+        map[entry.normalizedPath] = {
+            sha512: entry.sha512,
+            size: entry.size,
+        };
+        return map;
+    }, Object.create(null));
+}
+exports.assetsToAssetsMap = assetsToAssetsMap;
 /** Creates a manifest configuration sent up for deployment */
 async function createManifestAsync(params, graphqlClient) {
     // Resolve .env file variables
@@ -110,18 +151,6 @@ async function* listWorkerFilesAsync(workerPath) {
     }
 }
 exports.listWorkerFilesAsync = listWorkerFilesAsync;
-/** Reads files of an asset maps and enumerates normalized paths and data */
-async function* listAssetMapFilesAsync(assetPath, assetMap) {
-    for (const normalizedPath in assetMap) {
-        const filePath = node_path_1.default.resolve(assetPath, normalizedPath.split('/').join(node_path_1.default.sep));
-        yield {
-            normalizedPath,
-            path: filePath,
-            sha512: assetMap[normalizedPath],
-        };
-    }
-}
-exports.listAssetMapFilesAsync = listAssetMapFilesAsync;
 /** Packs file entries into a tar.gz file (path to tgz returned) */
 async function packFilesIterableAsync(iterable, options) {
     const writePath = `${await createTempWritePathAsync()}.tar.gz`;

package/build/worker/upload.d.ts

@@ -1,23 +1,35 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { HeadersInit, RequestInit, Response } from 'node-fetch';
-export interface UploadParams extends Omit<RequestInit, 'signal' | 'body'> {
+import { AssetFileEntry } from './assets';
+export type UploadPayload = {
     filePath: string;
-    compress?: boolean;
-    url: string;
+} | {
+    asset: AssetFileEntry;
+} | {
+    multipart: AssetFileEntry[];
+};
+export interface UploadRequestInit {
+    baseURL: string | URL;
     method?: string;
     headers?: HeadersInit;
-    body?: undefined;
     signal?: AbortSignal;
 }
 export interface UploadResult {
-    params: UploadParams;
+    payload: UploadPayload;
     response: Response;
 }
-export declare function uploadAsync(params: UploadParams): Promise<UploadResult>;
+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 {
-    params: UploadParams;
+    payload: UploadPayload;
+    progress: number;
 }
-export type BatchUploadSignal = UploadResult | UploadPending;
-export declare function batchUploadAsync(uploads: readonly UploadParams[]): AsyncGenerator<BatchUploadSignal>;
+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 {};