@sanity/runtime-cli 17.12.0 → 17.13.0-next.g2501ffa

package/dist/utils/functions/is-folder-larger-than.js

@@ -0,0 +1,38 @@
+import { readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Recursively validates the total size of a folder, including all nested files and subdirectories.
+ */
+export function isFolderLargerThan(folder, maxBytes) {
+    if (!statSync(folder).isDirectory()) {
+        throw new Error('Provided path is not a directory');
+    }
+    function recurse(f, bytesSoFar) {
+        let totalBytes = bytesSoFar;
+        const fileEntries = readdirSync(f);
+        for (const file of fileEntries) {
+            const filePath = path.join(f.toString(), file);
+            const stats = statSync(filePath);
+            if (stats.isFile()) {
+                totalBytes += stats.size;
+            }
+            else if (stats.isDirectory()) {
+                const result = recurse(filePath, totalBytes);
+                totalBytes = result.totalBytes;
+            }
+            // return early if we have already exceeded the maximum
+            if (totalBytes > maxBytes) {
+                return {
+                    totalBytes,
+                    exceededMax: true,
+                };
+            }
+        }
+        return {
+            totalBytes,
+            exceededMax: false,
+        };
+    }
+    const result = recurse(folder, 0);
+    return result.exceededMax;
+}

package/dist/utils/functions/prepare-asset.d.ts

@@ -1,6 +1,8 @@
+import AdmZip from 'adm-zip';
 import type { AssetPrepResult, FunctionResource, InstallerType } from '../types.js';
 export declare function prepareAsset({ blueprintFileDir, resource, installer, }: {
     blueprintFileDir: string;
     resource: FunctionResource;
     installer?: InstallerType;
 }): Promise<AssetPrepResult>;
+export declare function pathToZip(path: string): Promise<AdmZip>;

package/dist/utils/functions/prepare-asset.js

@@ -1,9 +1,11 @@
-import { existsSync } from 'node:fs';
-import { rm, stat } from 'node:fs/promises';
+import fs, { existsSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
 import path from 'node:path';
-import { MAX_ASSET_SIZE } from '../../constants.js';
+import AdmZip from 'adm-zip';
+import { CONVERT_BYTES_TO_MB, MAX_ASSET_SIZE } from '../../constants.js';
+import { getDependencyInfo, takeAutoInstallManifest, } from './dependency-info.js';
 import { detectNativeModules, errorMessage } from './detect-native-modules.js';
-import { getFolderSize } from './get-folder-size.js';
+import { isFolderLargerThan } from './is-folder-larger-than.js';
 import { resolveResourceDependencies } from './resolve-dependencies.js';
 import { shouldAutoResolveDependencies } from './should-auto-resolve-deps.js';
 import { shouldTranspileFunction } from './should-transpile.js';
@@ -15,6 +17,8 @@ export async function prepareAsset({ blueprintFileDir, resource, installer, }) {
     let functionPath = resolvedFunctionPath;
     let cleanup = async () => { };
     let wasBundled = false;
+    let dependenciesInstalled = false;
+    let autoInstall;
     const shouldTranspile = await shouldTranspileFunction(resource, functionPath);
     if (shouldTranspile.transpile) {
         try {
@@ -41,7 +45,8 @@ export async function prepareAsset({ blueprintFileDir, resource, installer, }) {
             transpiled: shouldTranspile.transpile,
             installer,
         });
-        await removeArcAutoInstallPackageJson(functionPath);
+        autoInstall = await takeAutoInstallManifest(functionPath);
+        dependenciesInstalled = true;
     }
     if (existsSync(path.join(functionPath, 'node_modules'))) {
         const modulesPath = path.join(functionPath, 'node_modules');
@@ -51,29 +56,60 @@ export async function prepareAsset({ blueprintFileDir, resource, installer, }) {
         }
     }
     try {
-        const size = getFolderSize(functionPath);
-        if (size > MAX_ASSET_SIZE) {
+        // First check the size before trying to create the zip file
+        const result = isFolderLargerThan(functionPath, MAX_ASSET_SIZE);
+        if (result) {
             throw new Error('Resource is larger than max asset size of 200 MB.');
         }
-        return { success: true, outputPath: functionPath, cleanup };
+        const zip = await pathToZip(functionPath);
+        // Add up the uncompressed sizes of all entries to get a more accurate size of the asset being uploaded
+        const zipEntrySize = zip
+            .getEntries()
+            .map((entry) => entry.header.size)
+            .reduce((a, b) => a + b, 0);
+        if (zipEntrySize > MAX_ASSET_SIZE) {
+            throw new Error(`Asset size of ${(zipEntrySize / CONVERT_BYTES_TO_MB).toFixed(2)} MB exceeds the maximum allowed size of 200 MB.`);
+        }
+        return {
+            success: true,
+            outputBuffer: await zip.toBufferPromise(),
+            fileExtension: 'zip',
+            assetParameter: 'src',
+            cleanup,
+            metadata: {
+                transpiled: shouldTranspile.transpile,
+                bundled: wasBundled,
+                dependenciesInstalled,
+                ...(await getDependencyInfo({
+                    sourceDir: resolvedFunctionPath,
+                    autoInstall,
+                    bundled: wasBundled,
+                })),
+                assetBytes: zipEntrySize,
+            },
+        };
     }
     catch (err) {
         return { success: false, cleanup, error: err instanceof Error ? err.message : `${err}` };
     }
 }
-/**
- * Remove file that contains the current date to prevent the hash from changing in the final asset.
- * @param functionPath The path to the built function
- */
-async function removeArcAutoInstallPackageJson(functionPath) {
-    const arcAutoInstallPackageJson = path.join(functionPath, 'node_modules', '_arc-autoinstall', 'package.json');
-    try {
-        const fileStat = await stat(arcAutoInstallPackageJson);
-        if (fileStat.isFile()) {
-            await rm(arcAutoInstallPackageJson);
-        }
-    }
-    catch {
-        // ignore errors
-    }
+export async function pathToZip(path) {
+    const stats = await stat(path);
+    const zip = new AdmZip(undefined, {
+        fs: {
+            ...fs,
+            // @ts-expect-error monkey patching to return matching mtime for builds
+            statSync(path, options) {
+                const s = fs.statSync(path, options);
+                if (s)
+                    s.mtime = new Date(0);
+                return s;
+            },
+        },
+    });
+    if (stats.isDirectory())
+        zip.addLocalFolder(path);
+    else
+        zip.addLocalFile(path, '', 'index.js');
+    return zip;
 }

package/dist/utils/studios/prepare-asset.js

@@ -1,16 +1,16 @@
 import { createWriteStream } from 'node:fs';
-import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path, { basename, dirname, join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { createGzip } from 'node:zlib';
 import { buildStudio, compareDependencyVersions } from '@sanity/cli-build/_internal/build';
+import { getLocalPackageVersion } from '@sanity/cli-core';
 import { pack } from 'tar-fs';
 export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
-    // validate resource has an externalId
-    if (!('externalId' in resource) ||
-        typeof resource.externalId !== 'string' ||
-        !resource.externalId) {
+    // validate resource has an appId
+    const appId = getAppId(resource);
+    if (!appId) {
         return {
             success: false,
             async cleanup() {
@@ -23,6 +23,8 @@ export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
         // no op
     };
     const studioPath = path.resolve(blueprintFileDir, resource.src);
+    // set only when auto-updates is on, because the build compares versions only then
+    let mismatchedPackages;
     try {
         const studioPathStat = await stat(studioPath);
         if (!studioPathStat.isDirectory()) {
@@ -48,14 +50,15 @@ export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
             await rm(outDir, { force: true, recursive: true });
             await rm(outFile, { force: true });
         };
-        const appId = resource.externalId;
         try {
             await buildStudio({
                 appId,
                 autoUpdatesEnabled: resource.autoUpdates.enabled,
                 checkAppId() { },
                 async compareDependencyVersions(packages) {
-                    return compareDependencyVersions(packages, studioPath, { appId });
+                    const result = await compareDependencyVersions(packages, studioPath, { appId });
+                    mismatchedPackages = result.mismatched.map((m) => m.pkg);
+                    return result;
                 },
                 determineBasePath() {
                     return resource.basePath ?? '/';
@@ -105,11 +108,18 @@ export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
         }
         // tar/gzip/write the built output
         await pipeline(pack(dirname(outDir), { entries: [basename(outDir)] }), createGzip(), createWriteStream(outFile));
+        const buffer = await readFile(outFile);
         return {
             success: true,
             cleanup,
-            // studio must be pre built (e.g. with `npm run build`) and tarred/gzipped
-            outputPath: outFile,
+            outputBuffer: buffer,
+            fileExtension: 'tar.gz',
+            assetParameter: 'src',
+            metadata: {
+                sanityVersion: await getInstalledSanityVersion(studioPath),
+                mismatchedPackages,
+                assetBytes: buffer.length,
+            },
         };
     }
     catch (error) {
@@ -137,3 +147,20 @@ function createSilentOutput() {
         },
     };
 }
+async function getInstalledSanityVersion(studioPath) {
+    try {
+        return (await getLocalPackageVersion('sanity', studioPath)) ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getAppId(resource) {
+    if ('externalId' in resource && typeof resource.externalId === 'string' && resource.externalId) {
+        return resource.externalId;
+    }
+    else if (resource.lifecycle?.ownershipAction?.type === 'attach') {
+        return resource.lifecycle.ownershipAction.id;
+    }
+    return undefined;
+}

package/dist/utils/types.d.ts

@@ -20,8 +20,6 @@ export type FunctionResource = FunctionGroqResource | BlueprintPubSubFunctionRes
 export type EventFunctionResource = Exclude<FunctionResource, BlueprintPubSubFunctionResource>;
 /** The `event` of any function resource that declares one */
 export type FunctionResourceEvent = EventFunctionResource['event'];
-/** Resource types that carry a deployable asset (have src: string) */
-export type AssetResource = FunctionResource | BlueprintStudioResource;
 /** @internal */
 export interface AuthParams {
     token: string;
@@ -52,7 +50,6 @@ export declare function isRoleResource(r: unknown): r is BlueprintRoleResource;
 export declare function isDatasetResource(r: unknown): r is BlueprintDatasetResource;
 export declare function isStudioResource(r: BlueprintResource): r is BlueprintStudioResource;
 export declare function isDurableFunctionResource(r: unknown): r is BlueprintDurableFunctionResource;
-export declare function isAssetResource(r: BlueprintResource): r is AssetResource;
 export declare function isWebhookResource(r: unknown): r is BlueprintDocumentWebhookResource;
 interface StackBase {
     id: string;
@@ -90,7 +87,22 @@ export interface StackMutation {
     };
     userMessage?: string;
     preDeploy?: boolean;
+    metadata?: DeployMetadata;
 }
+/**
+ * Facts about one deploy, stored with the Blueprint on the server.
+ * The API accepts it on stack update and never returns it.
+ */
+export interface DeployMetadata {
+    /** The environment that ran the deploy */
+    client?: Record<string, unknown>;
+    /** One entry per resource that had an asset prepared, plus what was learned while preparing it */
+    resources?: ResourceMetadata[];
+}
+export type ResourceMetadata = {
+    name: string;
+    type: string;
+} & Record<string, unknown>;
 /** @internal */
 export interface BuildPayloadOptions {
     data?: string;
@@ -301,13 +313,32 @@ export declare const INSTALLER_OPTIONS: readonly ['npm', 'pnpm', 'yarn'];
 export type InstallerType = 'npm' | 'pnpm' | 'yarn';
 export type AssetPrepResult = {
     success: true;
-    outputPath: string;
+    outputBuffer: Buffer;
+    fileExtension: string;
+    assetParameter: string;
     cleanup: () => Promise<void>;
+    /** Facts learned about the resource while preparing its asset. Sent as deploy metadata. */
+    metadata?: Record<string, unknown>;
 } | {
     success: false;
     cleanup: () => Promise<void>;
     error: string;
 };
+export type PrepAssetFn<R extends BlueprintResource> = (options: {
+    resource: R;
+    blueprintFileDir: string;
+    installer?: InstallerType;
+}) => Promise<AssetPrepResult>;
+export type PreDeployConfig = {
+    /** The resource type this config applies to or a function that returns true if this config applies to the given type. */
+    resourceType: string | ((type: string) => boolean);
+    /** Function that takes a resource and returns a buffer to be sent to blueprints. */
+    prepareAsset?: PrepAssetFn<BlueprintResource>;
+};
+export type AssetResource<R extends BlueprintResource> = {
+    resource: R;
+    prepareAsset: PrepAssetFn<R>;
+};
 export type Warning = {
     code: string;
     suggestions: string[];

package/dist/utils/types.js

@@ -31,9 +31,6 @@ export function isStudioResource(r) {
 export function isDurableFunctionResource(r) {
     return validateDurableFunction(r).length === 0;
 }
-export function isAssetResource(r) {
-    return isLocalFunctionResource(r) || isStudioResource(r);
-}
 export function isWebhookResource(r) {
     return validateDocumentWebhook(r).length === 0;
 }