@sanity/runtime-cli 17.8.0 → 17.9.0-blueprinit.g14aaebd

package/dist/cores/functions/test.js

@@ -1,34 +1,37 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { cwd } from 'node:process';
+import { dirname } from 'node:path';
 import { testAction } from '../../actions/functions/test.js';
 import config from '../../config.js';
-import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, STEP_PHASE_GLYPH, } from '../../constants.js';
+import { STEP_PHASE_GLYPH } from '../../constants.js';
 import { resolveDeployedResources } from '../../utils/blueprints/resolve-deployed-resources.js';
-import buildPayload from '../../utils/functions/build-payload.js';
-import { fetchAsset, fetchDocument } from '../../utils/functions/fetch-document.js';
+import { createDurableJsonCollector } from '../../utils/functions/durable-logs.js';
 import { findFunctionInResources, getFunctionNames } from '../../utils/functions/find.js';
 import { runFunction } from '../../utils/functions/invoke/nested.js';
-import { parseJsonObject } from '../../utils/parse-json-object.js';
+import { buildContext, buildInvokeOptions, collectInvokeInput, defaultInvocationDeps, resolveInvocationPlan, } from '../../utils/functions/invoke/resolve-invoke-type.js';
 import { isEventType, } from '../../utils/types.js';
 /**
  * CLI lines for a durable run, in emission order; bare `start` events dropped.
  * @param events
  */
 function renderStepTimeline(events) {
-    return events
-        .filter((event) => event.phase !== 'start')
-        .map((event) => {
+    const lines = [];
+    for (const event of events) {
+        if (event.kind === 'log') {
+            lines.push(`${event.timestamp} ${event.level.toUpperCase()} ${event.message}`);
+            continue;
+        }
+        if (event.phase === 'start')
+            continue;
         const glyph = STEP_PHASE_GLYPH[event.phase] ?? '•';
         const duration = typeof event.durationMs === 'number' ? ` (${Math.round(event.durationMs)}ms)` : '';
         const detail = event.phase === 'error' && event.error ? ` ${event.error.message}` : '';
-        return `  ${glyph} ${event.name} [${event.kind}]${duration}${detail}`;
-    });
+        lines.push(`  ${glyph} ${event.name} [${event.kind}]${duration}${detail}`);
+    }
+    return lines;
 }
 export async function functionTestCore(options) {
     const { blueprint, log, error, args, flags, helpText } = options;
     const { name: fnName } = args;
-    const { data, event, file, timeout, api, dataset, 'document-id': documentId, 'with-user-token': withUserToken, 'data-before': dataBefore, 'data-after': dataAfter, 'file-before': fileBefore, 'file-after': fileAfter, 'document-id-before': documentIdBefore, 'document-id-after': documentIdAfter, 'media-library-id': mediaLibraryId, } = flags;
+    const { event, timeout, api, 'with-user-token': withUserToken, 'no-wait': noWait } = flags;
     const { 'project-id': projectId = blueprint?.projectId, 'organization-id': organizationId = blueprint?.organizationId, } = flags;
     if (!fnName) {
         const functionNames = getFunctionNames(blueprint.resources);
@@ -54,9 +57,6 @@ export async function functionTestCore(options) {
     }
     try {
         const resource = findFunctionInResources(blueprint.resources, fnName); // throws if not found
-        const docFunction = resource.type === SANITY_FUNCTION_DOCUMENT;
-        const mediaFunction = resource.type === SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
-        const durableFunction = resource.type === SANITY_FUNCTION_DURABLE;
         const resolvedResources = await resolveDeployedResources({
             resources: blueprint.resources,
             stackId: blueprint.stackId,
@@ -65,112 +65,36 @@ export async function functionTestCore(options) {
                 : undefined,
             logger: log,
         });
-        const blueprintFileDir = dirname(blueprint.fileInfo.blueprintFilePath);
-        const isMediaSource = mediaFunction || (durableFunction && resource.event?.type === 'media-library');
-        const eventResourceType = isMediaSource ? 'media-library' : 'dataset';
-        const eventResourceId = (isMediaSource ? mediaLibraryId : `${projectId}.${dataset}`) || '';
-        const contextOptions = docFunction || mediaFunction || durableFunction
-            ? {
-                clientOptions: {
-                    apiVersion: api,
-                    dataset,
-                    projectId,
-                    organizationId,
-                },
-                eventResourceType,
-                eventResourceId,
-                functionResourceType: 'project',
-                functionResourceId: projectId || '',
-                resources: resolvedResources,
-                blueprintFileDir,
-            }
-            : { clientOptions: {}, resources: resolvedResources, blueprintFileDir };
-        // If the user sets the flag to use the real token set it in our options
-        if (withUserToken) {
-            contextOptions.clientOptions.token = config.token || undefined;
-        }
-        let before = null;
-        let after = null;
-        if (dataBefore && dataAfter) {
-            before = parseJsonObject(dataBefore);
-            after = parseJsonObject(dataAfter);
-        }
-        else if (fileBefore && fileAfter) {
-            let fileContents = readFileSync(join(cwd(), fileBefore), 'utf8');
-            before = parseJsonObject(fileContents);
-            fileContents = readFileSync(join(cwd(), fileAfter), 'utf8');
-            after = parseJsonObject(fileContents);
-        }
-        else if (documentIdBefore && documentIdAfter && docFunction) {
-            before = await fetchDocument(documentIdBefore, {
-                projectId,
-                dataset,
-                apiVersion: api,
-                apiHost: config.apiUrl,
-                token: config.token || undefined,
-            }, log);
-            after = await fetchDocument(documentIdAfter, {
-                projectId,
-                dataset,
-                apiVersion: api,
-                apiHost: config.apiUrl,
-                token: config.token || undefined,
-            }, log);
-        }
-        else if (documentIdBefore && documentIdAfter) {
-            before = await fetchAsset(documentIdBefore, {
-                mediaLibraryId,
-                apiVersion: api,
-                apiHost: config.apiUrl,
-                token: config.token || undefined,
-            }, log);
-            after = await fetchAsset(documentIdAfter, {
-                mediaLibraryId,
-                apiVersion: api,
-                apiHost: config.apiUrl,
-                token: config.token || undefined,
-            }, log);
-        }
-        let payload;
-        if (after) {
-            payload = after;
-        }
-        else {
-            if (documentId && docFunction) {
-                payload = await fetchDocument(documentId, {
-                    projectId,
-                    dataset,
-                    apiVersion: api,
-                    apiHost: config.apiUrl,
-                    token: config.token || undefined,
-                }, log);
-            }
-            else if (documentId) {
-                payload = await fetchAsset(documentId, {
-                    mediaLibraryId,
-                    apiVersion: api,
-                    apiHost: config.apiUrl,
-                    token: config.token || undefined,
-                }, log);
-            }
-            else {
-                payload = buildPayload({ data, file });
-            }
-        }
-        let invokeOptions;
-        if (docFunction || mediaFunction) {
-            invokeOptions = { event: eventType, payload, before, after };
-        }
-        else {
-            invokeOptions = { event: durableFunction ? 'durable' : 'scheduled', payload: { data: payload } };
-        }
+        const input = {
+            flags,
+            projectId,
+            organizationId,
+            api,
+            apiHost: config.apiUrl,
+            token: config.token || undefined,
+            withUserToken,
+            resources: resolvedResources,
+            blueprintFileDir: dirname(blueprint.fileInfo.blueprintFilePath),
+            log,
+        };
+        const plan = resolveInvocationPlan(resource);
+        const context = buildContext(plan, input);
+        const invokeInput = await collectInvokeInput(plan, input, defaultInvocationDeps);
+        const invokeOptions = buildInvokeOptions(plan, invokeInput, eventType);
         // Records each nested context.invoke() so they can be surfaced in order after the spinner resolves.
         const nestedRuns = [];
         let nestedOrder = 0;
-        const stepEvents = [];
-        const onStepEvent = durableFunction
+        const durableJson = createDurableJsonCollector();
+        const onStepEvent = plan.isDurable
             ? (event) => {
-                stepEvents.push(event);
+                if (flags.json) {
+                    durableJson.record(event);
+                    return;
+                }
+                for (const line of renderStepTimeline([event])) {
+                    if (line !== null)
+                        log(line);
+                }
             }
             : undefined;
         /**
@@ -185,7 +109,7 @@ export async function functionTestCore(options) {
         const runNested = async (nestedName, nestedPayload, ctx, depth, callStack) => {
             const order = ++nestedOrder;
             const nestedResource = findFunctionInResources(blueprint.resources, nestedName);
-            const result = await runFunction(nestedResource, { payload: { data: nestedPayload }, event: 'nested' }, { ...ctx, resources: resolvedResources }, { depth, callStack, onNestedInvoke: runNested });
+            const result = await runFunction(nestedResource, { payload: nestedPayload, event: 'nested' }, { ...ctx, resources: resolvedResources }, { depth, callStack, onNestedInvoke: runNested });
             nestedRuns.push({ order, name: nestedName, logs: result.logs, error: result.error });
             return result;
         };
@@ -204,12 +128,13 @@ export async function functionTestCore(options) {
             }
         };
         const spinner = log.ora('Executing function...').start();
-        const { json: response, logs, error, } = await testAction(resource, invokeOptions, contextOptions, {
+        const { json: response, logs, error, } = await testAction(resource, invokeOptions, context, {
             timeout: timeout ? timeout : resource.timeout,
             onNestedInvoke: runNested,
             depth: 0,
             callStack: [fnName],
             onStepEvent,
+            noWait,
         });
         if (error) {
             spinner.fail('Function execution failed.');
@@ -221,12 +146,6 @@ export async function functionTestCore(options) {
             logNestedRuns();
             const errorMessage = error.stack || error.message || error.name;
             const isTimeout = error.message?.includes('Timeout');
-            if (durableFunction && stepEvents.length > 0) {
-                log('Steps:');
-                for (const line of renderStepTimeline(stepEvents)) {
-                    log(line);
-                }
-            }
             return {
                 success: false,
                 error: errorMessage,
@@ -237,20 +156,26 @@ export async function functionTestCore(options) {
             };
         }
         spinner.succeed('Function execution succeeded.');
-        log('Logs:');
-        log(logs || '');
-        logNestedRuns();
-        if (response) {
-            log('Response:');
-            log(JSON.stringify(response, null, 2));
-        }
-        if (durableFunction && stepEvents.length > 0) {
-            log('Steps:');
-            for (const line of renderStepTimeline(stepEvents)) {
-                log(line);
+        if (!plan.isDurable) {
+            log('Logs:');
+            log(logs || '');
+            logNestedRuns();
+            if (response) {
+                log('Response:');
+                log(JSON.stringify(response, null, 2));
             }
         }
-        return { success: true, json: { response, logs } };
+        const durableResult = durableJson.result();
+        return {
+            success: true,
+            json: plan.isDurable
+                ? {
+                    response: response ?? null,
+                    steps: durableResult.steps,
+                    logs: durableResult.logs,
+                }
+                : { response, logs },
+        };
     }
     catch (error) {
         return {

package/dist/server/app.js

@@ -28,7 +28,7 @@ const app = (host, port, validateResources, executionOptions) => {
      */
     const nestedInvoke = async (name, payload, ctx, depth, callStack) => {
         const order = ++nestedOrder;
-        const result = await handleInvokeRequest(name, { data: payload }, { event: 'nested' }, ctx, validateResources, executionOptions, depth, callStack, nestedInvoke);
+        const result = await handleInvokeRequest(name, payload, { event: 'nested' }, ctx, validateResources, executionOptions, depth, callStack, nestedInvoke);
         broadcast({
             type: 'nested-invoke',
             name,
@@ -372,13 +372,13 @@ function parseInvokeRequest(body, blueprintFileDir) {
     }
     const metadataEvent = metadata.event;
     if (typeof metadataEvent !== 'string' ||
-        (!isEventType(metadataEvent) && metadataEvent !== 'scheduled')) {
+        (!isEventType(metadataEvent) && metadataEvent !== 'plain')) {
         throw new Error('Request body is not valid, `metadata.event` field is not one of `create`, `update`, `delete`, or `scheduled`');
     }
     let before = null;
     let after = null;
     // Only GROQ-based events (create, update, delete) have before and after fields
-    if (metadataEvent !== 'scheduled') {
+    if (metadataEvent !== 'plain') {
         if (!('before' in metadata)) {
             throw new Error('Request body is not valid, `metadata.before` field is missing');
         }
@@ -418,9 +418,7 @@ function parseInvokeRequest(body, blueprintFileDir) {
             },
             event,
         },
-        metadata: metadataEvent === 'scheduled'
-            ? { event: metadataEvent }
-            : { event: metadataEvent, before, after },
+        metadata: metadataEvent === 'plain' ? { event: metadataEvent } : { event: metadataEvent, before, after },
     };
 }
 export { app, buildApiUrl, parseDocumentUrl };

package/dist/server/static/components/payload-panel.js

@@ -127,7 +127,7 @@ class PayloadPanel extends ApiBaseElement {
     // for certain other specific function types, set the payload to something specific, or reload whatever was loaded into its document payload before
     switch (selectedFunction.type) {
       case this.SANITY_FUNCTION_SYNC_TAG_INVALIDATE:
-        this.#updateCodeView(this.api.store.payload, {data: {syncTags: ['s1:1234', 's2:5678']}})
+        this.#updateCodeView(this.api.store.payload, {syncTags: ['s1:1234', 's2:5678']})
         break
       default:
         this.#updateCodeView(this.api.store.payload, this.documentCacheByFunction[selectedIndex])

package/dist/utils/display/intro.d.ts

@@ -0,0 +1,6 @@
+/** A left-to-right reveal of the wordmark; the last frame is the finished line. */
+export declare function introFrames(): string[];
+/** Print the intro, animated when the terminal can show it and static when it cannot. */
+export declare function playIntro({ json }?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/utils/display/intro.js

@@ -0,0 +1,63 @@
+import { env, stdout } from 'node:process';
+import { onExit } from 'signal-exit';
+import { isInteractive } from '../interactive.js';
+import { styleText } from '../style-text.js';
+const INDENT = '  ';
+const WORDMARK = 'sanity';
+const TAIL = ' with blueprints';
+/** The leading edge of the reveal, densest first. */
+const GRADIENT = ['▓', '▒', '░'];
+const REVEAL_PER_FRAME = 1;
+const FRAME_MS = 45;
+/** Time the finished wordmark holds before the command's own output follows. */
+const HOLD_MS = 250;
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const CLEAR_LINE = '\x1b[2K';
+function style(revealed, edge) {
+    const wordmark = revealed.slice(0, WORDMARK.length);
+    const tail = revealed.slice(WORDMARK.length);
+    return INDENT + styleText(['bold', 'red'], wordmark) + styleText('dim', tail + edge);
+}
+/** A left-to-right reveal of the wordmark; the last frame is the finished line. */
+export function introFrames() {
+    const full = WORDMARK + TAIL;
+    const frames = [];
+    for (let revealed = REVEAL_PER_FRAME; revealed < full.length; revealed += REVEAL_PER_FRAME) {
+        const edge = GRADIENT.slice(0, Math.min(GRADIENT.length, full.length - revealed)).join('');
+        frames.push(style(full.slice(0, revealed), edge));
+    }
+    frames.push(style(full, ''));
+    return frames;
+}
+function animates() {
+    return isInteractive && env.TERM !== 'dumb' && !env.CI;
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Print the intro, animated when the terminal can show it and static when it cannot. */
+export async function playIntro({ json = false } = {}) {
+    if (json)
+        return;
+    const frames = introFrames();
+    const finished = frames.at(-1) ?? '';
+    if (!animates()) {
+        stdout.write(`\n${finished}\n\n`);
+        return;
+    }
+    stdout.write(`\n${HIDE_CURSOR}`);
+    const cancelExitHook = onExit(() => {
+        stdout.write(SHOW_CURSOR);
+    });
+    try {
+        for (const frame of frames) {
+            stdout.write(`\r${CLEAR_LINE}${frame}`);
+            await sleep(FRAME_MS);
+        }
+        await sleep(HOLD_MS);
+        stdout.write('\n\n');
+    }
+    finally {
+        stdout.write(SHOW_CURSOR);
+        cancelExitHook();
+    }
+}

package/dist/utils/display/prompt.d.ts

@@ -24,10 +24,13 @@ export declare function promptForOrganization({ token, knownOrganizationId, logg
 /**
  * Asks the user whether to scope a Blueprint to an organization or a project.
  */
-export declare function promptForScope({ allowBack, hasProjects, }?: {
+export declare function promptForScope({ allowBack, hasProjects, message, }?: {
     allowBack?: boolean;
     hasProjects?: boolean;
+    message?: string;
 }): Promise<ScopeType | Back>;
+/** Offers a recovery path after the selected scope cannot be read. */
+export declare function promptForScopeRecovery(): Promise<'exit' | 'retry'>;
 /**
  * Prompts the user to pick a project from a pre-fetched list of projects.
  * Use after promptForOrganization when the user chose project scope.

package/dist/utils/display/prompt.js

@@ -121,7 +121,7 @@ export async function promptForOrganization({ token, knownOrganizationId, logger
 /**
  * Asks the user whether to scope a Blueprint to an organization or a project.
  */
-export async function promptForScope({ allowBack = false, hasProjects = true, } = {}) {
+export async function promptForScope({ allowBack = false, hasProjects = true, message = 'How would you like to scope your Blueprint?', } = {}) {
     const choices = [
         {
             name: 'Organization',
@@ -136,12 +136,26 @@ export async function promptForScope({ allowBack = false, hasProjects = true, }
         },
     ];
     const answer = await select({
-        message: 'How would you like to scope your Blueprint?',
+        message,
         choices: withBackChoice(choices, allowBack),
         default: 'organization',
     });
     return answer;
 }
+/** Offers a recovery path after the selected scope cannot be read. */
+export async function promptForScopeRecovery() {
+    return await select({
+        message: 'What would you like to do?',
+        choices: [
+            {
+                name: 'Choose another organization or project',
+                value: 'retry',
+            },
+            { name: 'Exit', value: 'exit' },
+        ],
+        default: 'retry',
+    });
+}
 /**
  * Prompts the user to pick a project from a pre-fetched list of projects.
  * Use after promptForOrganization when the user chose project scope.

package/dist/utils/functions/child-process-wrapper.js

@@ -41,7 +41,7 @@ process.on('message', async (data) => {
 
   // Otherwise this is the initial start message. Support the legacy untyped
   // `{srcPath, payload}` shape as well as the new `{type: 'start', ...}`.
-  const {srcPath, payload, isDurable} = jsonData
+  const {srcPath, payload, isDurable, noWait} = jsonData
   const {context, ...event} = payload
 
   let logs = ''
@@ -83,9 +83,10 @@ process.on('message', async (data) => {
     if (isDurable) {
       json = await runDurable(
         handler,
-        {context, event, logger: console},
+        {context, event},
         {
           emit: (e) => process.send(JSON.stringify({type: 'step-event', event: e})),
+          wait: (ms) => new Promise((resolve) => setTimeout(resolve, noWait ? 0 : ms)),
         },
       )
     } else {

package/dist/utils/functions/child-runtime/durable.d.ts

@@ -1,5 +1,5 @@
 import type {DurableContext, DurableHandler, DurableLogger, GenericEvent} from '@sanity/functions'
-import type {DurableStepEvent} from '../../types.js'
+import type {DurableRuntimeEvent} from '../../types.js'
 
 type RunDurableArgs = {
   context: DurableContext
@@ -8,7 +8,7 @@ type RunDurableArgs = {
 }
 
 type DurableIO = {
-  emit: (event: DurableStepEvent) => void
+  emit: (event: DurableRuntimeEvent) => void
 }
 
 export function runDurable(

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

@@ -1,17 +1,60 @@
 import {performance} from 'node:perf_hooks'
+import {inspect} from 'node:util'
+
+/**
+ *
+ * @param duration
+ * @return {number}
+ */
+const durationToMs = (duration = {}) => {
+  const {days = 0, hours = 0, minutes = 0, seconds = 0} = duration
+  return (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000
+}
+
+/**
+ *
+ * @param args
+ */
+const formatArgs = (args) =>
+  args.map((a) => (typeof a === 'string' ? a : inspect(a, {depth: null}))).join(' ')
 
 /**
  * Runs a durable function handler
  * @param handler - callback being run
  * @param context - data to send to the operation
  * @param event - the step being run
- * @param logger
  * @param io
  */
-export async function runDurable(handler, {context, event, logger}, io) {
+export async function runDurable(handler, {context, event}, io) {
+  let currentStep = null
+  const streamLog = (level, args) => {
+    const date = new Date()
+    const timestamp = `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`
+
+    return io.emit({
+      timestamp,
+      kind: 'log',
+      phase: 'log',
+      step: currentStep,
+      level,
+      message: formatArgs(args),
+    })
+  }
+
+  // @todo: need to throw error for use of `console.log` in a durable function
+  const logger = {
+    log: (...a) => streamLog('info', a),
+    info: (...a) => streamLog('info', a),
+    warn: (...a) => streamLog('warn', a),
+    error: (...a) => streamLog('error', a),
+  }
+
   const track = async (name, kind, produce) => {
     io.emit({name, kind, phase: 'start'})
     const startedAt = performance.now()
+    const prev = currentStep
+    currentStep = name
+
     try {
       const value = await produce()
       io.emit({
@@ -35,11 +78,18 @@ export async function runDurable(handler, {context, event, logger}, io) {
         durationMs: performance.now() - startedAt,
       })
       throw err
+    } finally {
+      currentStep = prev
     }
   }
 
   const step = {
-    run: ({name, handler: fn}) => track(name, 'run', () => fn({logger, attempt: 1})),
+    run: ({name, handler: fn}) => track(name || 'step-run', 'run', () => fn({logger, attempt: 1})),
+    wait: ({name, duration}) =>
+      track(name, 'wait', async () => {
+        await io.wait(durationToMs(duration))
+        return undefined
+      }),
   }
 
   return handler({context, event, step, logger})

package/dist/utils/functions/durable-logs.d.ts

@@ -0,0 +1,16 @@
+import type { DurableLogEvent, DurableRuntimeEvent, DurableStepEvent } from '../types.js';
+type DurableLogLine = Pick<DurableLogEvent, 'level' | 'message'>;
+type DurableJsonStep = DurableStepEvent & {
+    logs: DurableLogLine[];
+};
+/**
+ * Records a durable log event
+ */
+export declare const createDurableJsonCollector: () => {
+    record: (event: DurableRuntimeEvent) => void;
+    result: () => {
+        steps: DurableJsonStep[];
+        logs: DurableLogLine[];
+    };
+};
+export {};

package/dist/utils/functions/durable-logs.js

@@ -0,0 +1,52 @@
+/**
+ * Records a durable log event
+ */
+export const createDurableJsonCollector = () => {
+    const steps = [];
+    const logLines = [];
+    const activeSteps = new Map();
+    function record(event) {
+        if (event.kind === 'log') {
+            const logLine = {
+                level: event.level,
+                message: event.message,
+            };
+            if (event.step === null) {
+                logLines.push(logLine);
+                return;
+            }
+            const step = activeSteps.get(event.step);
+            if (step) {
+                step.logs.push(logLine);
+                return;
+            }
+            logLines.push(logLine);
+            return;
+        }
+        if (event.phase === 'start') {
+            const step = {
+                ...event,
+                logs: [],
+            };
+            steps.push(step);
+            activeSteps.set(event.name, step);
+            return;
+        }
+        const step = activeSteps.get(event.name);
+        if (!step)
+            return;
+        step.phase = event.phase;
+        step.durationMs = event.durationMs;
+        if (event.phase === 'complete') {
+            step.output = event.output;
+        }
+        if (event.phase === 'error') {
+            step.error = event.error;
+        }
+        activeSteps.delete(event.name);
+    }
+    return {
+        record,
+        result: () => ({ steps, logs: logLines }),
+    };
+};