netlify-cli 27.11.2 → 27.12.1

package/dist/utils/deploy/deploy-site.d.ts

@@ -1,26 +1,46 @@
-import BaseCommand from '../../commands/base-command.js';
-import { type $TSFixMe } from '../../commands/types.js';
-import type { DeployEvent } from './status-cb.js';
+import type { NetlifyAPI } from '@netlify/api';
+import type { Config as FunctionsConfig } from '@netlify/zip-it-and-ship-it';
+import type BaseCommand from '../../commands/base-command.js';
+import type { File } from './file.js';
+import type { DeployEvent, StatusCallback } from './status-cb.js';
+import type { DeployConfig } from './types.js';
 import type { DeployEnvironmentVariable } from '../env/deploy-env-vars.js';
 export type { DeployEvent };
-export declare const deploySite: (command: BaseCommand, api: $TSFixMe, siteId: any, dir: any, { assetType, branch, concurrentHash, concurrentUpload, config, deployId, deployTimeout, draft, environment, filter, fnDir, functionsConfig, hashAlgorithm, manifestPath, maxRetry, packagePath, serverEnabled, serverManifestPath, siteRoot, skipFunctionsCache, statusCb, syncFileLimit, tmpDir, workingDir, }: {
+export interface DeploySiteOptions {
+    assetType?: 'file' | undefined;
+    branch?: string;
     concurrentHash?: number;
     concurrentUpload?: number;
+    /** The site configuration, uploaded as the deploy's `netlify.toml` */
+    config: DeployConfig;
+    deployId: string;
     deployTimeout?: number;
     draft?: boolean;
     environment?: DeployEnvironmentVariable[];
+    filter: (filename: string) => boolean;
+    fnDir?: string[];
+    functionsConfig?: FunctionsConfig | undefined;
+    hashAlgorithm?: string;
+    manifestPath?: string | undefined;
     maxRetry?: number;
-    packagePath?: string;
+    packagePath?: string | undefined;
     serverEnabled?: boolean;
-    serverManifestPath?: string;
-    statusCb?: (status: DeployEvent) => void;
+    serverManifestPath?: string | undefined;
+    siteRoot?: string | undefined;
+    skipFunctionsCache?: boolean | undefined;
+    statusCb?: StatusCallback;
     syncFileLimit?: number;
     tmpDir?: string;
-    fnDir?: string[];
     workingDir: string;
-}) => Promise<{
-    deployId: any;
-    deploy: any;
-    uploadList: any[];
+}
+export declare const deploySite: (command: BaseCommand, api: NetlifyAPI, siteId: string, dir: string, { assetType, branch, concurrentHash, concurrentUpload, config, deployId, deployTimeout, draft, environment, filter, fnDir, functionsConfig, hashAlgorithm, manifestPath, maxRetry, packagePath, serverEnabled, serverManifestPath, siteRoot, skipFunctionsCache, statusCb, syncFileLimit, tmpDir, workingDir, }: DeploySiteOptions) => Promise<{
+    deployId: string;
+    deploy: import("./util.js").ReadyDeploy;
+    uploadList: (import("./upload-files.js").EdgeFunctionUploadFile | import("./upload-files.js").ServerUploadFile | File | (import("./upload-files.js").FunctionUploadFile & {
+        hash: string;
+        relname: string;
+    }) | (import("./upload-files.js").InlineUploadFile & {
+        hash: string;
+    }))[];
 }>;
 //# sourceMappingURL=deploy-site.d.ts.map

package/dist/utils/deploy/deploy-site.js

@@ -18,31 +18,7 @@ const buildStatsString = (possibleParts) => {
     }
     return `${parts.slice(0, -1).join(', ')} and ${parts[parts.length - 1]}`;
 };
-export const deploySite = async (command, api, 
-// @ts-expect-error TS(7006) FIXME: Parameter 'siteId' implicitly has an 'any' type.
-siteId, 
-// @ts-expect-error TS(7006) FIXME: Parameter 'dir' implicitly has an 'any' type.
-dir, { 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-assetType, 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-branch, concurrentHash = DEFAULT_CONCURRENT_HASH, concurrentUpload = DEFAULT_CONCURRENT_UPLOAD, 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-config, 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-deployId, deployTimeout = DEFAULT_DEPLOY_TIMEOUT, draft = false, environment, 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-filter, fnDir = [], 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-functionsConfig, 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-hashAlgorithm, 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-manifestPath, maxRetry = DEFAULT_MAX_RETRY, packagePath, serverEnabled, serverManifestPath, 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-siteRoot, 
-// @ts-expect-error TS(2525) FIXME: Initializer provides no value for this binding ele... Remove this comment to see the full error message
-skipFunctionsCache, statusCb = () => {
+export const deploySite = async (command, api, siteId, dir, { assetType, branch, concurrentHash = DEFAULT_CONCURRENT_HASH, concurrentUpload = DEFAULT_CONCURRENT_UPLOAD, config, deployId, deployTimeout = DEFAULT_DEPLOY_TIMEOUT, draft = false, environment, filter, fnDir = [], functionsConfig, hashAlgorithm, manifestPath, maxRetry = DEFAULT_MAX_RETRY, packagePath, serverEnabled, serverManifestPath, siteRoot, skipFunctionsCache, statusCb = () => {
     /* default to noop */
 }, syncFileLimit = DEFAULT_SYNC_LIMIT, tmpDir = temporaryDirectory(), workingDir, }) => {
     statusCb({
@@ -57,7 +33,7 @@ skipFunctionsCache, statusCb = () => {
         hashFiles({
             assetType,
             concurrentHash,
-            directories: [dir, edgeFunctionsDistPath, deployConfigPath, dbMigrationsDistPath].filter(Boolean),
+            directories: [dir, edgeFunctionsDistPath, deployConfigPath, dbMigrationsDistPath].filter((d) => Boolean(d)),
             filter,
             hashAlgorithm,
             normalizer: deployFileNormalizer.bind(null, workingDir),
@@ -99,9 +75,7 @@ skipFunctionsCache, statusCb = () => {
         throw new Error('Nothing to deploy');
     }
     if (functionsWithNativeModules.length !== 0) {
-        const functionsWithNativeModulesMessage = functionsWithNativeModules
-            .map(({ name }) => `- ${name}`)
-            .join('\n');
+        const functionsWithNativeModulesMessage = functionsWithNativeModules.map(({ name }) => `- ${name}`).join('\n');
         warn(`Modules with native dependencies\n
     ${functionsWithNativeModulesMessage}
 
@@ -120,8 +94,7 @@ For more information, visit https://ntl.fyi/cli-native-modules.`);
     });
     const packageFrameworks = command.project.frameworks.get(command.workspacePackage ?? '');
     const primaryFramework = packageFrameworks?.[0];
-    // @ts-expect-error TS(2349) This expression is not callable
-    const cleanedParams = cleanDeep({
+    const params = {
         siteId,
         deploy_id: deployId,
         body: {
@@ -138,21 +111,27 @@ For more information, visit https://ntl.fyi/cli-native-modules.`);
             framework_version: primaryFramework?.detected.package?.version?.toString() ?? 'unknown',
             build_version: getNetlifyBuildVersion(),
         },
-    });
+    };
+    const cleanedParams = 
+    // @ts-expect-error FIXME(clean-deep): typings declare an ES `export default` but the package is CommonJS
+    cleanDeep(params);
     // cleanDeep deeply strips keys with empty strings, but empty strings are valid environment
     // variable values--a user can use an empty string to e.g. unset a variable only for a deploy.
     // This would result in payloads with a missing `value` key, which the API would reject.
     const deployParams = environment?.length
         ? { ...cleanedParams, body: { ...cleanedParams.body, environment } }
         : cleanedParams;
-    let deploy = await api.updateSiteDeploy(deployParams);
+    // FIXME(@netlify/api): `id` and `required` are optional on the updated deploy
+    let deploy = (await api.updateSiteDeploy(
+    // @ts-expect-error FIXME(@netlify/api): `functions_config` rejects zip-it-and-ship-it's `BuildData`, route `methods` and `traffic_rules` strings
+    deployParams));
     if (deployParams.body.async)
-        deploy = await waitForDiff(api, deploy.id, siteId, deployTimeout);
+        deploy = (await waitForDiff(api, deploy.id, siteId, deployTimeout));
     const { required: requiredFiles, required_functions: requiredFns, required_edge_functions: requiredEdgeFns, required_server: requiredServer, } = deploy;
     const newStats = buildStatsString([
         requiredFiles.length > 0 && pluralize(requiredFiles.length, 'file'),
-        (requiredFns?.length ?? 0) > 0 && pluralize(requiredFns.length, 'function'),
-        (requiredEdgeFns?.length ?? 0) > 0 && pluralize(requiredEdgeFns.length, 'edge function'),
+        requiredFns != null && requiredFns.length > 0 && pluralize(requiredFns.length, 'function'),
+        requiredEdgeFns != null && requiredEdgeFns.length > 0 && pluralize(requiredEdgeFns.length, 'edge function'),
         (requiredServer?.length ?? 0) > 0 && 'a server',
     ]);
     statusCb({
@@ -171,18 +150,17 @@ For more information, visit https://ntl.fyi/cli-native-modules.`);
         msg: 'Waiting for deploy to go live...',
         phase: 'start',
     });
-    deploy = await waitForDeploy(api, deployId, siteId, deployTimeout);
+    const readyDeploy = await waitForDeploy(api, deployId, siteId, deployTimeout);
     statusCb({
         type: 'wait-for-deploy',
         msg: draft ? 'Draft deploy is live!' : 'Deploy is live!',
         phase: 'stop',
     });
     await rm(tmpDir, { force: true, recursive: true });
-    const deployManifest = {
+    return {
         deployId,
-        deploy,
+        deploy: readyDeploy,
         uploadList,
     };
-    return deployManifest;
 };
 //# sourceMappingURL=deploy-site.js.map

package/dist/utils/deploy/drop-api.d.ts

@@ -18,7 +18,13 @@ export interface DropApiError extends Error {
 export declare const getDropToken: ({ apiBase, userAgent }: DropApiOptions) => Promise<string>;
 export declare const createDropDeploy: ({ apiBase, userAgent }: DropApiOptions, files: Record<string, string>, token: string, createdVia?: string) => Promise<DropDeployInfo>;
 export declare const uploadDropFile: ({ apiBase, userAgent }: DropApiOptions, deployId: string, filePath: string, body: fs.ReadStream | Buffer, token: string) => Promise<void>;
-export declare const waitForDropDeploy: ({ apiBase, userAgent }: DropApiOptions, siteId: string, deployId: string, timeout?: number) => Promise<Record<string, unknown>>;
+interface DropSiteDeploy {
+    state?: string;
+    error_message?: string;
+    ssl_url?: string;
+    url?: string;
+}
+export declare const waitForDropDeploy: ({ apiBase, userAgent }: DropApiOptions, siteId: string, deployId: string, timeout?: number) => Promise<DropSiteDeploy>;
 export declare const claimDropSite: ({ apiBase, userAgent }: DropApiOptions, siteId: string, dropToken: string, authToken: string) => Promise<void>;
 export interface UploadListItem {
     normalizedPath: string;

package/dist/utils/deploy/drop-api.js

@@ -44,8 +44,6 @@ export const createDropDeploy = async ({ apiBase, userAgent }, files, token, cre
 };
 // TODO: Migrate to @netlify/api when Drop endpoints are in the OpenAPI spec.
 export const uploadDropFile = async ({ apiBase, userAgent }, deployId, filePath, body, token) => {
-    // Node.js fetch needs `duplex: 'half'` for streaming bodies which isn't in standard RequestInit
-    /* eslint-disable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any */
     const normalizedFilePath = filePath.startsWith('/') ? filePath : `/${filePath}`;
     const response = await fetch(`${apiBase}/deploys/${deployId}/files${encodeURI(normalizedFilePath)}`, {
         method: 'PUT',
@@ -53,10 +51,10 @@ export const uploadDropFile = async ({ apiBase, userAgent }, deployId, filePath,
             'Content-Type': 'application/octet-stream',
             Authorization: `Bearer ${token}`,
         }),
-        body: body,
+        body,
+        // Node.js fetch requires this for streaming bodies
         duplex: 'half',
     });
-    /* eslint-enable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any */
     if (!response.ok) {
         const error = new Error(`Failed to upload file ${filePath}: ${String(response.status)} ${response.statusText}`);
         error.status = response.status;
@@ -79,6 +77,7 @@ export const waitForDropDeploy = async ({ apiBase, userAgent }, siteId, deployId
             return true;
         }
         if (data.state === 'error') {
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- an empty error message falls back to the generic one
             throw new Error(data.error_message || `Deploy ${deployId} had an error`);
         }
         return false;

package/dist/utils/deploy/file.d.ts

@@ -1,8 +1,10 @@
 import walker from 'folder-walker';
 export type OriginalFile = walker.Entry;
-export type File = walker.Entry & {
+export type HashedFile = OriginalFile & {
     hash: string;
-    assetType: string;
+};
+export type File = HashedFile & {
+    assetType: 'file';
     normalizedPath: string;
 };
 //# sourceMappingURL=file.d.ts.map

package/dist/utils/deploy/hash-config.d.ts

@@ -1,10 +1,9 @@
+import type { DeployConfig } from './types.js';
+import type { InlineUploadFile } from './upload-files.js';
 export declare const hashConfig: ({ config }: {
-    config: any;
-}) => {
-    assetType: string;
-    body: string;
+    config: DeployConfig | undefined;
+}) => InlineUploadFile & {
     hash: string;
-    normalizedPath: string;
 };
-export declare const serializeToml: (object: any) => string;
+export declare const serializeToml: (object: DeployConfig) => string;
 //# sourceMappingURL=hash-config.d.ts.map

package/dist/utils/deploy/hash-config.js

@@ -1,6 +1,5 @@
 import { createHash } from 'node:crypto';
 import tomlify from 'tomlify-j0.4';
-// @ts-expect-error TS(7031) FIXME: Binding element 'config' implicitly has an 'any' t... Remove this comment to see the full error message
 export const hashConfig = ({ config }) => {
     if (!config)
         throw new Error('Missing config option');
@@ -13,14 +12,12 @@ export const hashConfig = ({ config }) => {
         normalizedPath: 'netlify.toml',
     };
 };
-// @ts-expect-error TS(7006) FIXME: Parameter 'object' implicitly has an 'any' type.
 export const serializeToml = function (object) {
     return tomlify.toToml(object, { space: 2, replace: replaceTomlValue });
 };
 // `tomlify-j0.4` serializes integers as floats, e.g. `200.0`.
 // This is a problem with `redirects[*].status`.
-// @ts-expect-error TS(7006) FIXME: Parameter 'key' implicitly has an 'any' type.
-const replaceTomlValue = function (key, value) {
+const replaceTomlValue = function (_key, value) {
     return Number.isInteger(value) ? String(value) : false;
 };
 //# sourceMappingURL=hash-config.js.map

package/dist/utils/deploy/hash-files.d.ts

@@ -1,15 +1,16 @@
-import { $TSFixMe } from '../../commands/types.js';
+import type { File } from './file.js';
+import type { StatusCallback } from './status-cb.js';
 declare const hashFiles: ({ assetType, concurrentHash, directories, filter, hashAlgorithm, normalizer, statusCb, }: {
-    assetType?: string | undefined;
-    concurrentHash: $TSFixMe;
-    directories: $TSFixMe;
-    filter: $TSFixMe;
+    assetType?: 'file' | undefined;
+    concurrentHash: number;
+    directories: string[];
+    filter: ((filename: string) => boolean) | undefined;
     hashAlgorithm?: string | undefined;
-    normalizer?: $TSFixMe;
-    statusCb: $TSFixMe;
+    normalizer?: (file: File) => File;
+    statusCb: StatusCallback;
 }) => Promise<{
     files: Record<string, string>;
-    filesShaMap: Record<string, $TSFixMe[]>;
+    filesShaMap: Record<string, File[]>;
 }>;
 export default hashFiles;
 //# sourceMappingURL=hash-files.d.ts.map

package/dist/utils/deploy/hash-fns.d.ts

@@ -1,9 +1,44 @@
-import BaseCommand from '../../commands/base-command.js';
-import { $TSFixMe } from '../../commands/types.js';
-import type { ServerUploadFile } from './upload-files.js';
+import { type Config as FunctionsConfig, type FunctionResult, type TrafficRules } from '@netlify/zip-it-and-ship-it';
+import type BaseCommand from '../../commands/base-command.js';
+import type { StatusCallback } from './status-cb.js';
+import type { FunctionUploadFile, ServerUploadFile } from './upload-files.js';
+type HashedFunctionFile = FunctionUploadFile & {
+    hash: string;
+    relname: string;
+};
+declare const trafficRulesConfig: (trafficRules?: TrafficRules) => {
+    action: {
+        type: string;
+        config: {
+            rate_limit_config: {
+                algorithm: string;
+                window_size: number;
+                window_limit: number;
+            };
+            aggregate: {
+                keys: {
+                    type: string;
+                }[];
+            };
+            to: string | undefined;
+        };
+    };
+} | undefined;
+interface FunctionConfigPayload {
+    display_name: FunctionResult['displayName'];
+    excluded_routes: FunctionResult['excludedRoutes'];
+    generator: FunctionResult['generator'];
+    memory: FunctionResult['memory'];
+    region: FunctionResult['region'];
+    routes: FunctionResult['routes'];
+    build_data: FunctionResult['buildData'];
+    priority: FunctionResult['priority'];
+    traffic_rules: ReturnType<typeof trafficRulesConfig>;
+    vcpu: FunctionResult['vcpu'];
+}
 declare const hashFns: (command: BaseCommand, directories: string[], { concurrentHash, functionsConfig, hashAlgorithm, manifestPath, packagePath, rootDir, serverEnabled, serverManifestPath, skipFunctionsCache, statusCb, tmpDir, }: {
     concurrentHash?: number;
-    functionsConfig?: $TSFixMe;
+    functionsConfig?: FunctionsConfig | undefined;
     hashAlgorithm?: string | undefined;
     manifestPath?: string | undefined;
     packagePath?: string | undefined;
@@ -11,18 +46,18 @@ declare const hashFns: (command: BaseCommand, directories: string[], { concurren
     serverEnabled?: boolean | undefined;
     serverManifestPath?: string | undefined;
     skipFunctionsCache?: boolean | undefined;
-    statusCb: $TSFixMe;
-    tmpDir: $TSFixMe;
+    statusCb: StatusCallback;
+    tmpDir?: string | undefined;
 }) => Promise<{
     functionSchedules?: {
         name: string;
         cron: string;
     }[] | undefined;
     functions: Record<string, string>;
-    functionsWithNativeModules: $TSFixMe[];
-    shaMap?: Record<string, $TSFixMe> | undefined;
-    fnShaMap?: Record<string, $TSFixMe[]> | undefined;
-    fnConfig?: Record<string, $TSFixMe> | undefined;
+    functionsWithNativeModules: FunctionResult[];
+    shaMap?: Record<string, never> | undefined;
+    fnShaMap?: Record<string, HashedFunctionFile[]> | undefined;
+    fnConfig?: Record<string, FunctionConfigPayload> | undefined;
     server?: {
         sha: string;
         region?: string;

package/dist/utils/deploy/hasher-segments.d.ts

@@ -1,15 +1,19 @@
 import { Transform, Writable } from 'node:stream';
-import type { File, OriginalFile } from './file.js';
+import type { File } from './file.js';
 import type { StatusCallback } from './status-cb.js';
 export declare const hasherCtor: ({ concurrentHash, hashAlgorithm }: {
-    concurrentHash: any;
-    hashAlgorithm: any;
+    concurrentHash?: number;
+    hashAlgorithm: string;
 }) => Transform;
 export declare const fileNormalizerCtor: ({ assetType, normalizer: normalizeFunction, }: {
-    assetType: string;
-    normalizer?: (file: OriginalFile) => File;
+    assetType: 'file';
+    normalizer?: (file: File) => File;
 }) => Transform;
-export declare const manifestCollectorCtor: (filesObj: Record<string, unknown>, shaMap: Record<string, unknown[]>, { statusCb }: {
+export declare const manifestCollectorCtor: <T extends {
+    hash: string;
+    normalizedPath: string;
+    relname: string;
+}>(filesObj: Record<string, string>, shaMap: Record<string, T[]>, { statusCb }: {
     statusCb: StatusCallback;
 }) => Writable;
 export declare const fileFilterCtor: () => Transform;

package/dist/utils/deploy/hasher-segments.js

@@ -11,7 +11,6 @@ const hashFile = async (filePath, algorithm) => {
 };
 // a parallel transform stream segment ctor that hashes fileObj's created by folder-walker
 // TODO: use promises instead of callbacks
-// @ts-expect-error TS(7031) FIXME: Binding element 'concurrentHash' implicitly has an... Remove this comment to see the full error message
 export const hasherCtor = ({ concurrentHash, hashAlgorithm }) => {
     if (!concurrentHash)
         throw new Error('Missing required opts');

package/dist/utils/deploy/process-files.d.ts

@@ -7,7 +7,7 @@ export declare const deployFileNormalizer: (workingDir: string, file: File) => {
     stat: import("fs").Stats;
     type: "file" | "directory";
     hash: string;
-    assetType: string;
+    assetType: 'file';
     normalizedPath: string;
 };
 export declare const getDeployConfigPathIfExists: (workingDir: string) => Promise<string | undefined>;

package/dist/utils/deploy/process-files.js

@@ -39,6 +39,7 @@ const getDirectoryIfExists = async (directoryPath) => {
     catch {
         // no-op
     }
+    return undefined;
 };
 export const isEdgeFunctionFile = (filePath) => filePath.startsWith(`${PUBLIC_URL_PATH}/`);
 //# sourceMappingURL=process-files.js.map

package/dist/utils/deploy/types.d.ts

@@ -0,0 +1,17 @@
+import type { NetlifyConfig } from '@netlify/build';
+import type { MinimalHeader } from '@netlify/headers-parser';
+/**
+ * The parts of the resolved configuration a deploy reads and uploads. Satisfied both by the CLI's cached config and
+ * by the `NetlifyConfig` that `@netlify/build` hands to the deploy handler.
+ */
+export interface DeployConfig {
+    build: {
+        base: string;
+        publish?: string;
+    };
+    functions?: NetlifyConfig['functions'];
+    functionsDirectory?: string;
+    headers?: NetlifyConfig['headers'] | MinimalHeader[];
+    redirects?: unknown[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/deploy/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/utils/deploy/upload-files.d.ts

@@ -1,15 +1,20 @@
-import fs from 'fs';
 import type { NetlifyAPI } from '@netlify/api';
 import type { StatusCallback } from './status-cb.js';
 export type UploadApi = Pick<NetlifyAPI, 'uploadDeployFile' | 'uploadDeployFunction' | 'uploadDeployEdgeFunction' | 'uploadDeployServer'>;
 interface UploadFileBase {
     filepath: string;
     normalizedPath: string;
-    body?: fs.ReadStream;
+    body?: undefined;
 }
 export interface StaticUploadFile extends UploadFileBase {
     assetType: 'file';
 }
+export interface InlineUploadFile {
+    assetType: 'file';
+    body: string;
+    filepath?: undefined;
+    normalizedPath: string;
+}
 export interface FunctionUploadFile extends UploadFileBase {
     assetType: 'function';
     runtime?: string;
@@ -24,7 +29,7 @@ export interface ServerUploadFile extends UploadFileBase {
     assetType: 'server';
     hash: string;
 }
-export type UploadFile = StaticUploadFile | FunctionUploadFile | EdgeFunctionUploadFile | ServerUploadFile;
+export type UploadFile = StaticUploadFile | InlineUploadFile | FunctionUploadFile | EdgeFunctionUploadFile | ServerUploadFile;
 interface UploadFilesOptions {
     concurrentUpload: number;
     maxRetry: number;

package/dist/utils/deploy/upload-files.js

@@ -23,7 +23,8 @@ const uploadFiles = async (api, deployId, uploadList, { concurrentUpload, maxRet
     });
     const uploadFile = async (fileObj, index) => {
         const { body, filepath, normalizedPath } = fileObj;
-        const readStreamCtor = () => body ?? fs.createReadStream(filepath);
+        // FIXME(@netlify/api): octet-stream `body` is typed as `ReadStream` only, but an inline string body works too
+        const readStreamCtor = () => (body ?? fs.createReadStream(filepath));
         statusCb({
             type: 'upload',
             msg: `(${index}/${uploadList.length}) Uploading ${normalizedPath}...`,
@@ -131,12 +132,12 @@ const retryUpload = (uploadFn, maxRetry) => new Promise((resolve, reject) => {
         // Do something when backoff starts, e.g. show to the
         // user the delay before next reconnection attempt.
     });
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises -- FIXME: the listener's promise is discarded
     fibonacciBackoff.on('ready', tryUpload);
     fibonacciBackoff.on('fail', () => {
         reject(lastError);
     });
-    tryUpload();
+    void tryUpload();
 });
 export default uploadFiles;
 //# sourceMappingURL=upload-files.js.map

package/dist/utils/deploy/upload-source-zip.js

@@ -27,6 +27,7 @@ const DEFAULT_IGNORE_PATTERNS = [
     '.tmp*',
     '.temp*',
 ];
+const isExecaError = (error) => error instanceof Error && 'command' in error;
 const createSourceZip = async ({ sourceDir, filename, statusCb, }) => {
     // Check for Windows - this feature is not supported on Windows
     if (platform() === 'win32') {
@@ -54,13 +55,9 @@ const createSourceZip = async ({ sourceDir, filename, statusCb, }) => {
             stdio: ['ignore', 'pipe', 'pipe'],
         });
     }
-    catch (_baseErr) {
-        let message = 'zip command failed';
-        if (_baseErr instanceof Error && 'command' in _baseErr) {
-            const baseErr = _baseErr;
-            message = `${baseErr.shortMessage}\n\n${baseErr.all ?? ''}`;
-        }
-        throw new Error(message, { cause: _baseErr });
+    catch (error) {
+        const message = isExecaError(error) ? `${error.shortMessage}\n\n${error.all ?? ''}` : 'zip command failed';
+        throw new Error(message, { cause: error });
     }
     return zipPath;
 };

package/dist/utils/deploy/util.d.ts

@@ -1,6 +1,9 @@
+import type { NetlifyAPI } from '@netlify/api';
 export declare const pluralize: (amount: number, noun: string) => string;
+export type Deploy = Awaited<ReturnType<NetlifyAPI['getSiteDeploy']>>;
+export type ReadyDeploy = Deploy & Required<Pick<Deploy, 'id' | 'site_id' | 'name' | 'admin_url' | 'url' | 'ssl_url' | 'deploy_url' | 'deploy_ssl_url'>>;
 export declare const normalizePath: (relname: string) => string;
-export declare const waitForDiff: (api: any, deployId: any, siteId: any, timeout: any) => Promise<undefined>;
-export declare const waitForDeploy: (api: any, deployId: any, siteId: any, timeout: any) => Promise<undefined>;
-export declare const getUploadList: (required: any, shaMap: any) => any;
+export declare const waitForDiff: (api: Pick<NetlifyAPI, 'getSiteDeploy'>, deployId: string, siteId: string, timeout: number) => Promise<Deploy>;
+export declare const waitForDeploy: (api: Pick<NetlifyAPI, 'getSiteDeploy'>, deployId: string, siteId: string, timeout: number) => Promise<ReadyDeploy>;
+export declare const getUploadList: <T>(required: string[] | undefined, shaMap: Record<string, T[]> | undefined) => T[];
 //# sourceMappingURL=util.d.ts.map

package/dist/utils/deploy/util.js

@@ -10,17 +10,13 @@ export const normalizePath = (relname) => {
     return relname.split(sep).join('/');
 };
 // poll an async deployId until its done diffing
-// @ts-expect-error TS(7006) FIXME: Parameter 'api' implicitly has an 'any' type.
 export const waitForDiff = async (api, deployId, siteId, timeout) => {
-    // capture ready deploy during poll
-    let deploy;
     const loadDeploy = async () => {
         const siteDeploy = await api.getSiteDeploy({ siteId, deployId });
         switch (siteDeploy.state) {
             // https://github.com/netlify/bitballoon/blob/master/app/models/deploy.rb#L21-L33
             case 'error': {
                 const deployError = new Error(siteDeploy.error_message || `Deploy ${deployId} had an error`);
-                // @ts-expect-error TS(2339) FIXME: Property 'deploy' does not exist on type 'Error'.
                 deployError.deploy = siteDeploy;
                 throw deployError;
             }
@@ -28,8 +24,7 @@ export const waitForDiff = async (api, deployId, siteId, timeout) => {
             case 'uploading':
             case 'uploaded':
             case 'ready': {
-                deploy = siteDeploy;
-                return true;
+                return pWaitFor.resolveWith(siteDeploy);
             }
             case 'preparing':
             default: {
@@ -37,7 +32,7 @@ export const waitForDiff = async (api, deployId, siteId, timeout) => {
             }
         }
     };
-    await pWaitFor(loadDeploy, {
+    const deploy = await pWaitFor(loadDeploy, {
         interval: DEPLOY_POLL,
         timeout: {
             milliseconds: timeout,
@@ -47,23 +42,18 @@ export const waitForDiff = async (api, deployId, siteId, timeout) => {
     return deploy;
 };
 // Poll a deployId until its ready
-// @ts-expect-error TS(7006) FIXME: Parameter 'api' implicitly has an 'any' type.
 export const waitForDeploy = async (api, deployId, siteId, timeout) => {
-    // capture ready deploy during poll
-    let deploy;
     const loadDeploy = async () => {
         const siteDeploy = await api.getSiteDeploy({ siteId, deployId });
         switch (siteDeploy.state) {
             // https://github.com/netlify/bitballoon/blob/master/app/models/deploy.rb#L21-L33
             case 'error': {
                 const deployError = new Error(siteDeploy.error_message || `Deploy ${deployId} had an error`);
-                // @ts-expect-error TS(2339) FIXME: Property 'deploy' does not exist on type 'Error'.
                 deployError.deploy = siteDeploy;
                 throw deployError;
             }
             case 'ready': {
-                deploy = siteDeploy;
-                return true;
+                return pWaitFor.resolveWith(siteDeploy);
             }
             case 'preparing':
             case 'prepared':
@@ -74,7 +64,7 @@ export const waitForDeploy = async (api, deployId, siteId, timeout) => {
             }
         }
     };
-    await pWaitFor(loadDeploy, {
+    const deploy = await pWaitFor(loadDeploy, {
         interval: DEPLOY_POLL,
         timeout: {
             milliseconds: timeout,
@@ -84,11 +74,9 @@ export const waitForDeploy = async (api, deployId, siteId, timeout) => {
     return deploy;
 };
 // Transform the fileShaMap and fnShaMap into a generic shaMap that file-uploader.js can use
-// @ts-expect-error TS(7006) FIXME: Parameter 'required' implicitly has an 'any' type.
 export const getUploadList = (required, shaMap) => {
     if (!required || !shaMap)
         return [];
-    // @ts-expect-error TS(7006) FIXME: Parameter 'sha' implicitly has an 'any' type.
     return required.flatMap((sha) => shaMap[sha]);
 };
 //# sourceMappingURL=util.js.map