@sanity/runtime-cli 17.0.0 → 17.1.0

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

@@ -0,0 +1,306 @@
+import { spawn } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
+import { cwd } from 'node:process';
+import { setTimeout } from 'node:timers';
+import { fileURLToPath } from 'node:url';
+import * as groq from 'groq-js';
+import config from '../../../config.js';
+import { groupBlueprintResources } from '../../blueprints/group-resources.js';
+import { isGroqContextOptions, } from '../../types.js';
+import { acquireFunctionBuild } from './prepare.js';
+function getChildProcessWrapperPath() {
+    return fileURLToPath(new URL('../child-process-wrapper.js', import.meta.url));
+}
+export function sanitizeLogs(logs) {
+    return logs.replace(/([a-zA-Z0-9]{10})[a-zA-Z0-9]{65,}/g, '$1**********');
+}
+export async function applyGroqRule(resource, payload, projectId, dataset) {
+    const { before, after, payload: data = null } = payload;
+    // If there is no rule set return everything
+    if (!resource.event)
+        return data;
+    // default groq rule is: gimme full doc content. otherwise, parse + eval custom rule
+    // applying the GROQ filter may result in a slimmer set of documents
+    if (resource.event.filter || resource.event.projection) {
+        const query = `*[${resource.event.filter || ''}]${resource.event.projection || ''}`;
+        try {
+            const rule = groq.parse(query, { mode: 'delta' });
+            const sanity = projectId && dataset ? { projectId, dataset } : undefined;
+            const queryResults = await groq.evaluate(rule, { dataset: [data], before, after, sanity });
+            const currentFunctionDocumentSet = await queryResults.get();
+            return currentFunctionDocumentSet[0];
+        }
+        catch (groqErr) {
+            const detail = groqErr instanceof Error && `; ${groqErr.message}`;
+            throw new Error(`Invalid rule configuration: ${query}${detail}`, { cause: groqErr });
+        }
+    }
+    // default groq rule so just return the data
+    return data;
+}
+export default async function invoke(resource, payload, context, options) {
+    if (!resource.src) {
+        throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
+    }
+    const { forceColor = true, timeout = 10, onNestedInvoke, depth = 0, callStack = [] } = options;
+    // Apply the GROQ rule before preparing a build so a filtered-out event skips
+    // the (potentially expensive) transpile entirely.
+    let filteredData = payload?.payload?.data || {};
+    if (resource.type === 'sanity.function.document' ||
+        resource.type === 'sanity.function.media-library.asset') {
+        if (!isGroqContextOptions(context)) {
+            throw new Error('GROQ-based functions require a context with clientOptions');
+        }
+        const { projectId, dataset } = context.clientOptions;
+        if ('before' in payload) {
+            filteredData = await applyGroqRule(resource, payload, projectId, dataset);
+            if (typeof filteredData === 'undefined') {
+                return {
+                    logs: `⚠️ Filter "${resource.event?.filter}" returned an empty result. Skipping invoke.`,
+                    error: undefined,
+                    json: undefined,
+                };
+            }
+        }
+    }
+    // Acquire a shared, reference-counted build. Concurrent invokes of the same
+    // function reuse one transpile + temp package.json instead of racing on the
+    // per-function build paths; the build is torn down once every invoke releases.
+    const build = acquireFunctionBuild(resource);
+    let functionPath;
+    let bundleTimings;
+    try {
+        const prepared = await build.ready;
+        functionPath = prepared.functionPath;
+        bundleTimings = prepared.bundleTimings;
+    }
+    catch (err) {
+        await build.release();
+        throw err;
+    }
+    return new Promise((resolve, reject) => {
+        let child;
+        let timer;
+        let executionStart;
+        // The protocol is no longer one-shot: the child stays alive across nested
+        // `context.invoke` calls, so several handlers (result/exit/error/timeout)
+        // can race to settle this Promise. `settled` ensures exactly one wins and
+        // that shutdown/cleanup only runs once.
+        let settled = false;
+        // Timeout budget is paused while nested invokes run so a function's own
+        // time limit isn't consumed by the functions it calls.
+        let pendingNested = 0;
+        let timerStart = 0;
+        let remaining = timeout * 1000;
+        const nestedTimings = {};
+        // Output the child writes directly to its stdio pipes (anything that escapes
+        // the in-process console capture, e.g. a native crash). Hoisted to the
+        // Promise scope so both the timeout and exit handlers can surface it.
+        let stdout = '';
+        let stderr = '';
+        function startTimer() {
+            timerStart = performance.now();
+            timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                // Resolve with error to retain all logs
+                resolve({
+                    json: undefined,
+                    logs: sanitizeLogs(stdout),
+                    error: {
+                        name: 'Error',
+                        message: `Timeout: Function exceeded the ${timeout}-second time limit.`,
+                        stack: '',
+                    },
+                    timings: {
+                        ...bundleTimings,
+                        ...nestedTimings,
+                        execute: executionTimeMs,
+                    },
+                });
+            }, Math.max(0, remaining));
+        }
+        function pauseTimer() {
+            if (pendingNested === 0) {
+                clearTimeout(timer);
+                remaining -= performance.now() - timerStart;
+            }
+            pendingNested += 1;
+        }
+        function resumeTimer() {
+            pendingNested -= 1;
+            if (pendingNested === 0 && !settled) {
+                startTimer();
+            }
+        }
+        // Resolve a nested `context.invoke(name, payload)` by re-entering the invoke
+        // pipeline via the supplied callback, then hand the result back to the child.
+        async function handleNestedInvoke(msg) {
+            const { id, name, payload: nestedPayload } = msg;
+            pauseTimer();
+            const nestedStart = performance.now();
+            try {
+                if (!onNestedInvoke) {
+                    throw new Error('Nested context.invoke is not supported in this context');
+                }
+                const nested = await onNestedInvoke(name, nestedPayload ?? {}, context, depth + 1, callStack);
+                nestedTimings[`invoke:${name}`] =
+                    (nestedTimings[`invoke:${name}`] ?? 0) + (performance.now() - nestedStart);
+                // Fire-and-forget contract: in production `context.invoke` returns once the
+                // message is enqueued (Lambda InvocationType:'Event', SNS/SQS), so a
+                // downstream handler error never reaches the caller. Mirror that here —
+                // the target ran (it was "dispatched"), so resolve the caller regardless
+                // of `nested.error`. The error isn't lost: it travels back in the returned
+                // result and is logged/streamed to the UI by the caller (app/test core).
+                if (child && !child.killed) {
+                    const response = {
+                        type: 'invoke-response',
+                        id,
+                        ok: true,
+                        result: { json: nested.json },
+                    };
+                    child.send(JSON.stringify(response));
+                }
+            }
+            catch (error) {
+                // The invoke could not be dispatched at all (unknown function, recursion
+                // guard, unsupported context). That is an enqueue-time failure, which in
+                // production rejects synchronously, so propagate it to the caller.
+                if (child && !child.killed) {
+                    const response = {
+                        type: 'invoke-response',
+                        id,
+                        ok: false,
+                        error: {
+                            message: error instanceof Error ? error.message : String(error),
+                            stack: error instanceof Error ? (error.stack ?? '') : '',
+                            name: error instanceof Error ? error.name : 'Error',
+                        },
+                    };
+                    child.send(JSON.stringify(response));
+                }
+            }
+            finally {
+                resumeTimer();
+            }
+        }
+        function start() {
+            executionStart = performance.now();
+            child = spawn('node', ['--enable-source-maps', getChildProcessWrapperPath()], {
+                cwd: cwd(),
+                stdio: ['pipe', 'pipe', 'pipe', 'ipc'], // changed: use 'pipe' so we can capture output
+                env: { ...process.env, ...resource.env, FORCE_COLOR: forceColor ? '1' : '0' },
+            });
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('message', (data) => {
+                let msg;
+                try {
+                    msg = JSON.parse(data.toString());
+                }
+                catch {
+                    return;
+                }
+                // Nested invoke request — handle without tearing down the child.
+                if (msg?.type === 'invoke-request') {
+                    handleNestedInvoke({ id: msg.id, name: msg.name, payload: msg.payload });
+                    return;
+                }
+                // Terminal result message.
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                resolve({
+                    json: msg.json,
+                    logs: sanitizeLogs(msg.logs ?? ''),
+                    error: msg.error,
+                    timings: {
+                        ...bundleTimings,
+                        ...nestedTimings,
+                        execute: executionTimeMs,
+                    },
+                });
+            });
+            child.on('error', (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                shutdown();
+                reject(new Error(`encountered error ${error.message}`));
+            });
+            // Resolve on 'close' to drain the pipes
+            child.on('close', (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                if (code !== 0) {
+                    // use captured stderr if available
+                    const message = stderr.trim().length > 0
+                        ? `Process failed with code ${code}\n${stderr}`
+                        : `exited with code ${code}`;
+                    // Resolve with error to retain all logs
+                    resolve({
+                        json: undefined,
+                        logs: sanitizeLogs(stdout),
+                        error: { name: 'Error', message, stack: '' },
+                        timings: {
+                            ...bundleTimings,
+                            ...nestedTimings,
+                            execute: executionTimeMs,
+                        },
+                    });
+                }
+                else {
+                    resolve({
+                        json: undefined,
+                        logs: sanitizeLogs(stdout),
+                        error: undefined,
+                        timings: {
+                            ...bundleTimings,
+                            ...nestedTimings,
+                            execute: executionTimeMs,
+                        },
+                    });
+                }
+            });
+            startTimer();
+            const payload = {
+                data: { ...filteredData },
+                context: {
+                    ...context,
+                    local: true,
+                    resources: groupBlueprintResources(context.resources ?? []),
+                    ...(isGroqContextOptions(context) && {
+                        clientOptions: {
+                            ...context.clientOptions,
+                            apiHost: config.apiUrl,
+                        },
+                    }),
+                },
+            };
+            const startMessage = { type: 'start', srcPath: functionPath, payload };
+            child.send(JSON.stringify(startMessage));
+        }
+        function shutdown() {
+            clearTimeout(timer);
+            if (child && !child.killed) {
+                child.kill();
+            }
+            // Release our reference to the shared build; its temp package.json and
+            // bundle are cleaned up once the last concurrent invoke releases.
+            build.release().catch((err) => console.warn('Build cleanup failed:', err));
+        }
+        start();
+    });
+}

package/dist/utils/functions/invoke/nested.d.ts

@@ -0,0 +1,25 @@
+import type { FunctionResource, InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadOptions } from '../../types.js';
+/**
+ * Upper bound on nested `context.invoke` recursion, a backstop against invoke loops.
+ * Set to 16 to match Functions service lineage limit.
+ */
+export declare const MAX_INVOKE_DEPTH = 16;
+/**
+ * Guard a nested `context.invoke(name)` against runaway recursion and cycles.
+ * `depth` is the depth at which the target would run and `callStack` is the chain
+ * of function names already running (innermost last). Throws a descriptive error
+ * when the call must be rejected; returns normally when it is safe to proceed.
+ *
+ * This is an enqueue-time check: it runs before the target is dispatched, so the
+ * throw propagates to the caller's `context.invoke` (unlike a downstream handler
+ * error, which is fire-and-forget). See `handleNestedInvoke` in local.ts.
+ */
+export declare function assertNestedInvokeAllowed(name: string, depth: number, callStack: string[]): void;
+/**
+ * Execute a single already-resolved function in its own child process as one
+ * step of an invoke chain: enforce the depth/cycle guard, run it with the call
+ * stack extended by this function, and normalize timings.
+ */
+export declare function runFunction(resource: FunctionResource, payload: InvokePayloadOptions, context: InvokeContextOptions, options: InvokeExecutionOptions): Promise<InvocationResponse & {
+    timings: Record<string, number>;
+}>;

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

@@ -0,0 +1,41 @@
+import invoke from './local.js';
+/**
+ * Upper bound on nested `context.invoke` recursion, a backstop against invoke loops.
+ * Set to 16 to match Functions service lineage limit.
+ */
+export const MAX_INVOKE_DEPTH = 16;
+/**
+ * Guard a nested `context.invoke(name)` against runaway recursion and cycles.
+ * `depth` is the depth at which the target would run and `callStack` is the chain
+ * of function names already running (innermost last). Throws a descriptive error
+ * when the call must be rejected; returns normally when it is safe to proceed.
+ *
+ * This is an enqueue-time check: it runs before the target is dispatched, so the
+ * throw propagates to the caller's `context.invoke` (unlike a downstream handler
+ * error, which is fire-and-forget). See `handleNestedInvoke` in local.ts.
+ */
+export function assertNestedInvokeAllowed(name, depth, callStack) {
+    if (depth > MAX_INVOKE_DEPTH) {
+        throw new Error(`Maximum invoke depth (${MAX_INVOKE_DEPTH}) exceeded`);
+    }
+    if (callStack.includes(name)) {
+        throw new Error(`Invoke cycle detected: ${[...callStack, name].join(' → ')}`);
+    }
+}
+/**
+ * Execute a single already-resolved function in its own child process as one
+ * step of an invoke chain: enforce the depth/cycle guard, run it with the call
+ * stack extended by this function, and normalize timings.
+ */
+export async function runFunction(resource, payload, context, options) {
+    const { forceColor, timeout, depth = 0, callStack = [], onNestedInvoke } = options;
+    assertNestedInvokeAllowed(resource.name, depth, callStack);
+    const response = await invoke(resource, payload, context, {
+        forceColor,
+        timeout: timeout ?? resource.timeout,
+        onNestedInvoke,
+        depth,
+        callStack: [...callStack, resource.name],
+    });
+    return { ...response, timings: response.timings ?? {} };
+}

package/dist/utils/functions/invoke/prepare.d.ts

@@ -0,0 +1,20 @@
+import type { FunctionResource } from '../../types.js';
+/** Everything a child process needs to run a prepared function. */
+export interface PreparedFunction {
+    /** Absolute path to the entry file the child should import. */
+    functionPath: string;
+    /** Timings recorded while bundling, merged into the invocation result. */
+    bundleTimings?: Record<string, number>;
+}
+/** A reference-counted handle to a shared build. Call `release()` once per acquire. */
+export interface FunctionBuild {
+    ready: Promise<PreparedFunction>;
+    release: () => Promise<void>;
+}
+/**
+ * Acquire a shared, reference-counted build for `resource`. The first caller runs
+ * the transpile + temp package.json setup; concurrent callers reuse it. Every
+ * caller MUST call `release()` exactly once when its child has exited, so the
+ * shared artifacts are torn down only after the last in-flight invoke finishes.
+ */
+export declare function acquireFunctionBuild(resource: FunctionResource): FunctionBuild;

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

@@ -0,0 +1,90 @@
+import { findFunctionEntryPoint } from '../find-entry-point.js';
+import { cleanupTempPackageJson, createTempPackageJson, doesPackageJsonExists, } from '../package-json.js';
+import { resolveResourceDependencies } from '../resolve-dependencies.js';
+import { shouldAutoResolveDependencies } from '../should-auto-resolve-deps.js';
+import { shouldTranspileFunction } from '../should-transpile.js';
+import { transpileFunction } from '../transpile/function.js';
+/**
+ * In-progress builds keyed by function identity. Concurrent invokes of the same
+ * function (e.g. `Promise.all([context.invoke('f'), context.invoke('f')])`) share
+ * a single build and a single temp package.json, so they don't race on the
+ * deterministic per-function paths (`.build/function-<name>`, the temp
+ * package.json). The entry is removed once the last concurrent invoke releases
+ * it, so a later, non-overlapping invoke rebuilds and picks up source changes.
+ */
+const builds = new Map();
+function buildKey(resource) {
+    return `${resource.name}:${resource.src}`;
+}
+/**
+ * Acquire a shared, reference-counted build for `resource`. The first caller runs
+ * the transpile + temp package.json setup; concurrent callers reuse it. Every
+ * caller MUST call `release()` exactly once when its child has exited, so the
+ * shared artifacts are torn down only after the last in-flight invoke finishes.
+ */
+export function acquireFunctionBuild(resource) {
+    const key = buildKey(resource);
+    let entry = builds.get(key);
+    if (!entry) {
+        let cleanupBundle = async () => { };
+        let functionPath = '';
+        let createdTempPackageJson = false;
+        // If no package.json exists we create a temporary one to avoid the
+        // "module type" warning from node.
+        const existingPackageJson = doesPackageJsonExists(resource);
+        const ready = (async () => {
+            if (!resource.src) {
+                throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
+            }
+            let bundleTimings;
+            const shouldTranspile = await shouldTranspileFunction(resource);
+            if (shouldTranspile) {
+                const transpileResult = await transpileFunction(resource);
+                functionPath = await findFunctionEntryPoint(transpileResult.outputDir);
+                bundleTimings = transpileResult.timings;
+                cleanupBundle = transpileResult.cleanup;
+            }
+            else {
+                functionPath = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+            }
+            const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
+            if (shouldResolveDependencies && existingPackageJson) {
+                await resolveResourceDependencies(resource, { transpiled: shouldTranspile });
+            }
+            if (!existingPackageJson) {
+                createTempPackageJson(functionPath);
+                createdTempPackageJson = true;
+            }
+            return { functionPath, bundleTimings };
+        })();
+        entry = {
+            refs: 0,
+            ready,
+            teardown: async () => {
+                // rmSync is synchronous, so the temp package.json is gone before this
+                // function yields — a later invoke of the same function can't observe a
+                // half-removed state.
+                if (createdTempPackageJson) {
+                    cleanupTempPackageJson(functionPath);
+                }
+                await cleanupBundle().catch((err) => console.warn('Bundle cleanup failed:', err));
+            },
+        };
+        builds.set(key, entry);
+    }
+    const activeEntry = entry;
+    activeEntry.refs += 1;
+    let released = false;
+    const release = async () => {
+        if (released)
+            return;
+        released = true;
+        activeEntry.refs -= 1;
+        if (activeEntry.refs === 0) {
+            if (builds.get(key) === activeEntry)
+                builds.delete(key);
+            await activeEntry.teardown();
+        }
+    };
+    return { ready: activeEntry.ready, release };
+}

package/dist/utils/isTrueish.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Quick check for 'true' or '1' from env
+ * @param val
+ */
+declare const isTrueish: (val?: string) => boolean;
+export default isTrueish;

package/dist/utils/isTrueish.js

@@ -0,0 +1,9 @@
+/**
+ * Quick check for 'true' or '1' from env
+ * @param val
+ */
+const isTrueish = (val) => {
+    const v = (val ?? '').toLowerCase();
+    return v === 'true' || parseInt(v, 10) > 0;
+};
+export default isTrueish;

package/dist/utils/types.d.ts

@@ -98,13 +98,14 @@ export interface InvokeGroqPayloadOptions {
     before: Record<string, unknown> | null;
     after: Record<string, unknown> | null;
 }
-export interface InvokeSchedulePayloadOptions {
+export interface InvokeNonGroqPayloadOptions {
     payload?: Record<string, unknown>;
-    event: 'scheduled';
+    event: NonGroqEventType;
 }
-export type InvokePayloadOptions = InvokeGroqPayloadOptions | InvokeSchedulePayloadOptions;
-export type InvokePayloadMetadata = Pick<InvokeGroqPayloadOptions, 'event' | 'before' | 'after'> | Pick<InvokeSchedulePayloadOptions, 'event'>;
+export type InvokePayloadOptions = InvokeGroqPayloadOptions | InvokeNonGroqPayloadOptions;
+export type InvokePayloadMetadata = Pick<InvokeGroqPayloadOptions, 'event' | 'before' | 'after'> | Pick<InvokeNonGroqPayloadOptions, 'event'>;
 export type EventType = 'create' | 'update' | 'delete';
+export type NonGroqEventType = 'scheduled' | 'nested';
 export declare function isEventType(arg: string): arg is EventType;
 /** @internal */
 export interface InvokeGroqContextOptions {
@@ -140,7 +141,64 @@ export declare function isGroqContextOptions(context: InvokeContextOptions): con
 export interface InvokeExecutionOptions {
     forceColor?: boolean;
     timeout?: number;
+    /**
+     * Callback used to resolve a nested `context.invoke(name, payload)` made from
+     * within a running function. When absent, nested invokes are rejected.
+     * @internal
+     */
+    onNestedInvoke?: NestedInvoke;
+    /** Current invocation depth, used to bound nested `context.invoke` recursion. @internal */
+    depth?: number;
+    /** Function names already on the invoke call stack (innermost last), used to detect cycles. @internal */
+    callStack?: string[];
 }
+/**
+ * Re-entrant callback that executes a named function from the blueprint on behalf
+ * of a nested `context.invoke(name, payload)` and returns its invocation result.
+ * @internal
+ */
+export type NestedInvoke = (name: string, payload: Record<string, unknown>, context: InvokeContextOptions, depth: number, callStack: string[]) => Promise<InvocationResponse & {
+    timings: Record<string, number>;
+}>;
+/**
+ * IPC messages sent from the parent (invoke-local) down to a function child process.
+ * @internal
+ */
+export type ParentToChildMessage = {
+    type: 'start';
+    srcPath: string;
+    payload: unknown;
+} | {
+    type: 'invoke-response';
+    id: string;
+    ok: true;
+    result: {
+        json: JsonInvocationResponse | undefined;
+    };
+} | {
+    type: 'invoke-response';
+    id: string;
+    ok: false;
+    error: InvocationError;
+};
+/**
+ * IPC messages sent from a function child process back up to the parent.
+ * `result` is terminal and triggers shutdown; `invoke-request` is a nested
+ * `context.invoke` awaiting a correlated `invoke-response`.
+ * @internal
+ */
+export type ChildToParentMessage = {
+    type: 'invoke-request';
+    id: string;
+    name: string;
+    payload: Record<string, unknown>;
+} | {
+    type: 'result';
+    json?: JsonInvocationResponse;
+    logs?: string;
+    errorLogs?: string;
+    error?: InvocationError;
+};
 /** @internal */
 export interface InvocationResponse {
     error: InvocationError | undefined;