@sanity/runtime-cli 17.12.0 → 17.12.1

package/dist/cores/blueprints/logs.js

@@ -4,6 +4,7 @@ import { formatTitle } from '../../utils/display/blueprints-formatting.js';
 import { formatLogEntry, formatLogs } from '../../utils/display/logs-formatting.js';
 import { niceId } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 /** Number of recent logs to show before entering watch mode */
 const WATCH_PREFETCH_LIMIT = 10;
 export async function blueprintLogsCore(options) {
@@ -11,8 +12,9 @@ export async function blueprintLogsCore(options) {
     const { watch = false, verbose = false, limit, since, before } = flags;
     const spinner = log.ora(`Fetching recent logs for Stack deployment ${niceId(stackId)}`).start();
     try {
+        const fetchFn = createTracedFetch(log);
         if (watch) {
-            const { ok, logs, error } = await getLogs({ stackId, limit: WATCH_PREFETCH_LIMIT }, auth, log);
+            const { ok, logs, error } = await getLogs({ stackId, limit: WATCH_PREFETCH_LIMIT }, auth, fetchFn);
             if (!ok) {
                 spinner.fail(`${styleText('red', 'Failed')} to retrieve logs`);
                 log.error(`Error: ${error || 'Unknown error'}`);
@@ -38,9 +40,13 @@ export async function blueprintLogsCore(options) {
                 stackId,
                 knownIds: logs.map((l) => l.id),
                 auth,
-                log,
-                showBanner: true,
-                verbose,
+                fetchFn,
+                onShowBanner() {
+                    log(`Watching logs... ${styleText('bold', 'ctrl+c')} to cancel`);
+                },
+                onLogEntry(logEntry, previousLog) {
+                    log(formatLogEntry(logEntry, verbose, previousLog));
+                },
             });
             // Return a never-resolving promise so the polling loop keeps running
             return {
@@ -49,7 +55,7 @@ export async function blueprintLogsCore(options) {
             };
         }
         // One-shot fetch (no watch)
-        const { ok, logs, error, hasMore } = await getLogs({ stackId, limit, before, after: since }, auth, log);
+        const { ok, logs, error, hasMore } = await getLogs({ stackId, limit, before, after: since }, auth, fetchFn);
         if (!ok) {
             spinner.fail(`${styleText('red', 'Failed')} to retrieve Stack deployment logs`);
             log.error(`Error: ${error || 'Unknown error'}`);

package/dist/cores/functions/build.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { pathToZip } from '../../actions/blueprints/assets.js';
+import { CONVERT_BYTES_TO_MB } from '../../constants.js';
 import { findFunctionInResources } from '../../utils/functions/find.js';
 import { prepareAsset } from '../../utils/functions/prepare-asset.js';
 import { isLocalFunctionResource } from '../../utils/types.js';
@@ -31,14 +31,13 @@ export async function functionBuildCore(options) {
             errors.push({ name: resource.name, error: prepResult.error ?? 'Unknown error' });
             continue;
         }
-        const zip = await pathToZip(prepResult.outputPath);
-        const buffer = zip.toBuffer();
+        const buffer = prepResult.outputBuffer;
         const zipPath = path.join(outDir, `${resource.name}.zip`);
-        await fs.promises.writeFile(zipPath, buffer);
+        await fs.promises.writeFile(zipPath, prepResult.outputBuffer);
         if (prepResult.cleanup) {
             await prepResult.cleanup();
         }
-        const sizeMb = (buffer.length / 1_048_576).toFixed(1);
+        const sizeMb = (buffer.length / CONVERT_BYTES_TO_MB).toFixed(1);
         spinner.succeed(`${resource.name}.zip (${sizeMb} MB) → ${zipPath}`);
         built.push({ name: resource.name, size: buffer.length, path: zipPath });
     }

package/dist/cores/functions/test.js

@@ -7,6 +7,7 @@ import { createDurableJsonCollector } from '../../utils/functions/durable-logs.j
 import { findFunctionInResources, getFunctionNames } from '../../utils/functions/find.js';
 import { runFunction } from '../../utils/functions/invoke/nested.js';
 import { buildContext, buildInvokeOptions, collectInvokeInput, defaultInvocationDeps, resolveInvocationPlan, } from '../../utils/functions/invoke/resolve-invoke-type.js';
+import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { isEventType, } from '../../utils/types.js';
 export async function functionTestCore(options) {
     const { blueprint, log, error, args, flags, helpText } = options;
@@ -36,6 +37,7 @@ export async function functionTestCore(options) {
         };
     }
     try {
+        const fetchFn = createTracedFetch(log);
         const resource = findFunctionInResources(blueprint.resources, fnName); // throws if not found
         const resolvedResources = await resolveDeployedResources({
             resources: blueprint.resources,
@@ -43,7 +45,7 @@ export async function functionTestCore(options) {
             auth: config.token && blueprint.scopeType && blueprint.scopeId
                 ? { token: config.token, scopeType: blueprint.scopeType, scopeId: blueprint.scopeId }
                 : undefined,
-            logger: log,
+            fetchFn,
         });
         const input = {
             flags,

package/dist/cores/index.js

@@ -1,6 +1,7 @@
 import { readLocalBlueprint } from '../actions/blueprints/blueprint.js';
 import { getStack, resolveStackIdByNameOrId } from '../actions/blueprints/stacks.js';
 import { presentBlueprintParserErrors } from '../utils/display/errors.js';
+import { createTracedFetch } from '../utils/traced-fetch.js';
 import { validTokenOrErrorMessage } from '../utils/validated-token.js';
 export async function initBlueprintConfig({ bin, log, token, validateResources = false, validateToken = true, blueprintPath, }) {
     let checkedToken = token;
@@ -51,7 +52,8 @@ export async function initDeployedBlueprintConfig(config) {
         return { ok: false, error: 'Missing Stack deployment configuration for Blueprint' };
     }
     const spinner = config.log.ora('Loading Stack deployment...').start();
-    const stackResponse = await getStack({ stackId, auth, logger: config.log });
+    const fetchFn = createTracedFetch(config.log);
+    const stackResponse = await getStack({ stackId, auth, fetchFn });
     if (!stackResponse.ok) {
         spinner.fail('Could not load Stack deployment');
         return { ok: false, error: 'Missing Stack deployment' };

package/dist/server/handlers/invoke.js

@@ -16,7 +16,7 @@ export async function handleInvokeRequest(functionName, event, metadata, context
         resources,
         stackId,
         auth: config.token && scopeType && scopeId ? { token: config.token, scopeType, scopeId } : undefined,
-        logger: silentLogger,
+        fetchFn: fetch,
     });
     const payload = {
         payload: event,

package/dist/utils/blueprints/resolve-deployed-resources.d.ts

@@ -1,11 +1,10 @@
 import type { BlueprintResource } from '@sanity/blueprints';
-import type { Logger } from '../logger.js';
 import type { AuthParams } from '../types.js';
 interface ResolveOptions {
     resources: BlueprintResource[];
     stackId?: string;
     auth?: AuthParams;
-    logger: Logger;
+    fetchFn: typeof fetch;
 }
 /**
  * Returns the local blueprint resources, annotated with externalIds from the
@@ -13,5 +12,5 @@ interface ResolveOptions {
  * resources that aren't yet deployed are preserved without an externalId.
  * Any failure to fetch the stack falls back to the raw local resources.
  */
-export declare function resolveDeployedResources({ resources, stackId, auth, logger, }: ResolveOptions): Promise<BlueprintResource[]>;
+export declare function resolveDeployedResources({ resources, stackId, auth, fetchFn, }: ResolveOptions): Promise<BlueprintResource[]>;
 export {};

package/dist/utils/blueprints/resolve-deployed-resources.js

@@ -5,11 +5,11 @@ import { getStack } from '../../actions/blueprints/stacks.js';
  * resources that aren't yet deployed are preserved without an externalId.
  * Any failure to fetch the stack falls back to the raw local resources.
  */
-export async function resolveDeployedResources({ resources, stackId, auth, logger, }) {
+export async function resolveDeployedResources({ resources, stackId, auth, fetchFn, }) {
     if (!stackId || !auth?.token || !auth.scopeType || !auth.scopeId)
         return resources;
     try {
-        const response = await getStack({ stackId, auth, logger });
+        const response = await getStack({ stackId, auth, fetchFn });
         if (!response.ok || !Array.isArray(response.stack?.resources))
             return resources;
         const deployedByKey = new Map();

package/dist/utils/blueprints/wait-for.d.ts

@@ -0,0 +1,60 @@
+import type { Logger } from '../logger.js';
+import type { BlueprintLog } from '../types.js';
+/** Delay before the first operation poll. Override with SANITY_OPERATION_POLL_INITIAL_DELAY_MS. */
+export declare const OPERATION_POLL_INITIAL_DELAY_MS: number;
+/** Interval between operation status polls. Override with SANITY_OPERATION_POLL_INTERVAL_MS. */
+export declare const OPERATION_POLL_INTERVAL_MS: number;
+/** Consecutive failed polls tolerated before giving up on confirming status. */
+export declare const OPERATION_POLL_MAX_CONSECUTIVE_ERRORS = 5;
+/** Result of waiting for a deploy/destroy operation to settle. */
+export type OperationOutcome = {
+    type: 'completed';
+} | {
+    type: 'failed';
+    logHints: string[];
+} | {
+    type: 'unconfirmed';
+    error?: string;
+};
+type EndState = 'completed' | 'failed';
+export type StateInfo = {
+    state: EndState;
+} | {
+    state: 'pending';
+    /** Used to avoid repeatedly outputting pending status messages. */
+    latestStatus: string;
+    verboseMessage: string;
+} | {
+    state: 'not_found';
+    verboseError: string;
+} | {
+    state: 'error';
+    error: string | null;
+    verboseError: string;
+};
+type WaitForOptions = {
+    /**
+     * Requests the latest state and returns it to the main loop for processing.
+     * @returns The current state of the thing we are waiting for
+     */
+    onRequestLatestState: () => Promise<StateInfo>;
+    /**
+     * Called when the waitFor logic should start reading logs.
+     * @returns A function that stops the polling process when invoked.
+     */
+    onStartLogPolling: (options: {
+        onActivity?: () => void;
+        onLogEntry?: (log: BlueprintLog, previousLog: BlueprintLog | undefined) => void;
+    }) => () => void;
+    getIdleMessage: () => string;
+};
+export type WaitForFn = (options: WaitForOptions) => Promise<OperationOutcome>;
+export declare function createWaitFor({ bin, log, verbose, initialDelayMs, pollIntervalMs, idleSpinnerDelayMs, }: {
+    bin: string;
+    log: Logger;
+    verbose?: boolean;
+    initialDelayMs?: number;
+    pollIntervalMs?: number;
+    idleSpinnerDelayMs?: number;
+}): WaitForFn;
+export {};

package/dist/utils/blueprints/wait-for.js

@@ -0,0 +1,115 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import { formatLogEntry } from '../display/logs-formatting.js';
+import { runCommand } from '../package-manager.js';
+import { createHintCollector } from './hints.js';
+const envMs = (value, fallback) => {
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+};
+/** Delay before the first operation poll. Override with SANITY_OPERATION_POLL_INITIAL_DELAY_MS. */
+export const OPERATION_POLL_INITIAL_DELAY_MS = envMs(process.env.SANITY_OPERATION_POLL_INITIAL_DELAY_MS, 1000);
+/** Interval between operation status polls. Override with SANITY_OPERATION_POLL_INTERVAL_MS. */
+export const OPERATION_POLL_INTERVAL_MS = envMs(process.env.SANITY_OPERATION_POLL_INTERVAL_MS, 1500);
+/** Consecutive failed polls tolerated before giving up on confirming status. */
+export const OPERATION_POLL_MAX_CONSECUTIVE_ERRORS = 5;
+const IDLE_SPINNER_DELAY_MS = 30_000;
+const IDLE_SPINNER_UPDATE_INTERVAL_MS = 15_000;
+export function createWaitFor({ bin, log, verbose, initialDelayMs = OPERATION_POLL_INITIAL_DELAY_MS, pollIntervalMs = OPERATION_POLL_INTERVAL_MS, idleSpinnerDelayMs = IDLE_SPINNER_DELAY_MS, }) {
+    return async (options) => {
+        const logHints = createHintCollector(bin);
+        let logStreamCleanup = null;
+        let idleSpinner;
+        const stopIdleSpinner = (restoreOperationProgress = false) => {
+            if (!idleSpinner)
+                return;
+            idleSpinner.stop();
+            idleSpinner = undefined;
+            if (restoreOperationProgress)
+                log.showProgress();
+        };
+        try {
+            log.showProgress();
+            let lastLogAt = Date.now();
+            let nextIdleSpinnerUpdateAt = idleSpinnerDelayMs;
+            let consecutiveErrors = 0;
+            let lastStatus;
+            logStreamCleanup = options.onStartLogPolling({
+                onActivity: () => {
+                    lastLogAt = Date.now();
+                    nextIdleSpinnerUpdateAt = idleSpinnerDelayMs;
+                    stopIdleSpinner(true);
+                },
+                onLogEntry: (logEntry, previousLog) => {
+                    logHints.inspectLog(logEntry);
+                    log(formatLogEntry(logEntry, verbose, previousLog));
+                },
+            });
+            // balk in case read replica lags
+            await sleep(initialDelayMs);
+            while (true) {
+                const stateInfo = await options.onRequestLatestState();
+                if (stateInfo.state === 'completed') {
+                    if (logStreamCleanup)
+                        logStreamCleanup();
+                    stopIdleSpinner();
+                    log('');
+                    return { type: 'completed' };
+                }
+                if (stateInfo.state === 'failed') {
+                    if (logStreamCleanup)
+                        logStreamCleanup();
+                    stopIdleSpinner();
+                    log('');
+                    return { type: 'failed', logHints: logHints.getSuggestions() };
+                }
+                // tolerate a few consecutive errors; the operation was accepted and may still be running
+                if (stateInfo.state === 'error') {
+                    consecutiveErrors += 1;
+                    log.verbose(`${stateInfo.verboseError}; retrying (${consecutiveErrors}/${OPERATION_POLL_MAX_CONSECUTIVE_ERRORS}).`);
+                    if (consecutiveErrors >= OPERATION_POLL_MAX_CONSECUTIVE_ERRORS) {
+                        if (logStreamCleanup)
+                            logStreamCleanup();
+                        stopIdleSpinner();
+                        log('');
+                        return { type: 'unconfirmed', error: stateInfo.error ?? undefined };
+                    }
+                }
+                else {
+                    consecutiveErrors = 0;
+                    if (stateInfo.state === 'not_found') {
+                        log.verbose(stateInfo.verboseError);
+                    }
+                    else if (stateInfo.state === 'pending' && stateInfo.latestStatus !== lastStatus) {
+                        log.verbose(stateInfo.verboseMessage);
+                        lastStatus = stateInfo.latestStatus;
+                    }
+                }
+                const idleFor = Date.now() - lastLogAt;
+                if (idleFor >= nextIdleSpinnerUpdateAt) {
+                    const elapsedIdleMs = idleSpinnerDelayMs +
+                        Math.floor((idleFor - idleSpinnerDelayMs) / IDLE_SPINNER_UPDATE_INTERVAL_MS) *
+                            IDLE_SPINNER_UPDATE_INTERVAL_MS;
+                    const elapsedIdleSeconds = elapsedIdleMs / 1000;
+                    const text = `No new activity for ${elapsedIdleSeconds} seconds. ${options.getIdleMessage()} You can safely exit and check status later with \`${runCommand(bin)} blueprints info\`.`;
+                    if (idleSpinner)
+                        idleSpinner.start(text);
+                    else
+                        idleSpinner = log.ora(text).start();
+                    nextIdleSpinnerUpdateAt = elapsedIdleMs + IDLE_SPINNER_UPDATE_INTERVAL_MS;
+                }
+                await sleep(pollIntervalMs);
+            }
+        }
+        catch (error) {
+            if (logStreamCleanup)
+                logStreamCleanup();
+            throw error;
+        }
+        finally {
+            stopIdleSpinner();
+            log.clearProgress();
+        }
+    };
+}

package/dist/utils/functions/child-runtime/durable.js

@@ -107,13 +107,13 @@ export async function runDurable(handler, {context, event}, io) {
         }
         return state
       }),
-    delegate: ({name, handler, input}) =>
+    delegate: ({name, handler, event}) =>
       track(name || '', 'delegate', () => {
         const fn = typeof handler === 'string' ? handler : handler?.name
         if (!fn) {
           throw new Error('No function name provided for delegation')
         }
-        return io.invoke(fn, input)
+        return io.invoke(fn, event)
       }),
   }
 

package/dist/utils/functions/invoke/assert-console.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Asserts that a given source file does not contain any `console` usage.
+ * @param src
+ */
+export declare const assertConsole: (src: string) => void;

package/dist/utils/functions/invoke/assert-console.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { parseSync, Visitor } from 'vite';
+const EXTENSIONS = ['', '.ts', '.js', '.mjs', '.cjs'];
+/**
+ * Resolves a local module if it exists.
+ * @param fromFile
+ * @param specifier
+ */
+const resolveLocalModule = (fromFile, specifier) => {
+    const base = resolve(dirname(fromFile), specifier);
+    const candidates = [
+        base,
+        base.replace(/\.js$/, '.ts'),
+        ...EXTENSIONS.map((ext) => base + ext),
+        ...EXTENSIONS.map((ext) => resolve(base, `index${ext}`)),
+    ];
+    return candidates.find((candidate) => EXTENSIONS.includes(extname(candidate)) && existsSync(candidate) && !candidate.endsWith('/'));
+};
+/**
+ * Asserts that a given source file does not contain any `console` usage.
+ * @param src
+ */
+export const assertConsole = (src) => {
+    const seen = new Set();
+    const stack = [src];
+    while (stack.length > 0) {
+        const file = stack.pop();
+        if (!file || seen.has(file)) {
+            continue;
+        }
+        seen.add(file);
+        const { program, module: esm, errors } = parseSync(file, readFileSync(file, 'utf8'));
+        if (errors.length > 0) {
+            throw new Error(`Failed to parse ${file}: ${errors.map((e) => e.message).join(', ')}`);
+        }
+        new Visitor({
+            MemberExpression(node) {
+                if (node.object.type === 'Identifier' && node.object.name === 'console') {
+                    // @todo: improve error message to include doc link.
+                    const err = new Error('Console logging is not allowed in Durable functions. ' +
+                        `at ${file} ` +
+                        'Use the provided durable logger `logger.log()` or `ctx.log()` instead.');
+                    err.stack = undefined;
+                    throw err;
+                }
+            },
+        }).visit(program);
+        const isLocal = (str) => str.startsWith('./') || str.startsWith('../');
+        const imports = esm.staticImports.map((item) => item.moduleRequest.value);
+        const reExports = esm.staticExports.flatMap((exp) => exp.entries.flatMap((entry) => entry.moduleRequest && !entry.isType ? [entry.moduleRequest.value] : []));
+        const specs = [...imports, ...reExports].filter(isLocal);
+        for (const spec of specs) {
+            const resolved = resolveLocalModule(file, spec);
+            if (resolved) {
+                stack.push(resolved);
+            }
+        }
+    }
+};

package/dist/utils/functions/invoke/local.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { cwd } from 'node:process';
 import { setTimeout } from 'node:timers';
@@ -8,6 +9,8 @@ import config from '../../../config.js';
 import { SANITY_FUNCTION_DURABLE } from '../../../constants.js';
 import { groupBlueprintResources } from '../../blueprints/group-resources.js';
 import { isGroqContextOptions, } from '../../types.js';
+import { findFunctionEntryPoint } from '../find-entry-point.js';
+import { assertConsole } from './assert-console.js';
 import { acquireFunctionBuild } from './prepare.js';
 import { isGroqInvocation } from './resolve-invoke-type.js';
 function getChildProcessWrapperPath() {
@@ -48,6 +51,12 @@ export default async function invoke(resource, payload, context, options) {
         throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
     }
     const { forceColor = true, timeout = 10, onNestedInvoke, depth = 0, callStack = [], onStepEvent = () => { }, noWait = false, } = options;
+    // Ensure a user when running a durable is using the provided logger and not the `console`
+    if (resource.type === SANITY_FUNCTION_DURABLE) {
+        const sourcePath = resolve(context.blueprintFileDir, resource.src);
+        const entry = await findFunctionEntryPoint(sourcePath, resource?.displayName || resource.name);
+        assertConsole(entry);
+    }
     // `payload.payload` is the event body for every function type: the document for
     // GROQ-based events, whatever the producer sent for the rest. The handler always
     // receives it as `event.data` (see the `payload` built in `start()` below).

package/dist/utils/functions/is-folder-larger-than.d.ts

@@ -0,0 +1,5 @@
+import { type PathLike } from 'node:fs';
+/**
+ * Recursively validates the total size of a folder, including all nested files and subdirectories.
+ */
+export declare function isFolderLargerThan(folder: PathLike, maxBytes: number): boolean;

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,10 @@
-import { existsSync } from 'node:fs';
+import fs, { existsSync } from 'node:fs';
 import { rm, 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 { 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';
@@ -51,16 +52,52 @@ 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,
+        };
     }
     catch (err) {
         return { success: false, cleanup, error: err instanceof Error ? err.message : `${err}` };
     }
 }
+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;
+}
 /**
  * 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

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

@@ -1,5 +1,5 @@
 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';
@@ -105,11 +105,13 @@ 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',
         };
     }
     catch (error) {

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;
@@ -301,13 +298,30 @@ 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>;
 } | {
     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[];