@sanity/runtime-cli 17.15.0 → 17.16.0-next.g05d3b7f

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

@@ -10,6 +10,17 @@ export function createInvoker() {
   const pending = new Map()
   let invokeSeq = 0
 
+  function sendInvokeRequest(name, payload = {}, metadata = {}) {
+    if (typeof name !== 'string' || name.length === 0) {
+      return Promise.reject(new Error('context.invoke requires a function name'))
+    }
+    const id = String(++invokeSeq)
+    return new Promise((resolve, reject) => {
+      pending.set(id, {resolve, reject})
+      process.send(JSON.stringify({type: 'invoke-request', id, name, payload, metadata}))
+    })
+  }
+
   /**
    * `context.invoke(name, payload)` — ask the parent to execute another blueprint
    * function and resolve with its return value. Sent over IPC and correlated by id.
@@ -18,14 +29,20 @@ export function createInvoker() {
    * @returns {Promise<unknown>}
    */
   function invoke(name, payload = {}) {
-    if (typeof name !== 'string' || name.length === 0) {
-      return Promise.reject(new Error('context.invoke requires a function name'))
-    }
-    const id = String(++invokeSeq)
-    return new Promise((resolve, reject) => {
-      pending.set(id, {resolve, reject})
-      process.send(JSON.stringify({type: 'invoke-request', id, name, payload}))
-    })
+    return sendInvokeRequest(name, payload)
+  }
+
+  /**
+   * durable `step.delegate(name, payload)` — ask the parent durable to execute another blueprint function
+   * and resolve with its return value. Sent over IPC and correlated by id. Adds an `origin` field to the message so the parent can
+   * distinguish between a normal invoke and a durable delegate for logging purposes.
+   * @param {string} name
+   * @param {Record<string, unknown>} [payload]
+   * @returns {Promise<unknown>}
+   */
+  function delegate(name, payload = {}) {
+    const metadata = {origin: 'step.delegate'}
+    return sendInvokeRequest(name, payload, metadata)
   }
 
   function handleResponse(msg) {
@@ -43,5 +60,5 @@ export function createInvoker() {
     }
   }
 
-  return {invoke, handleResponse}
+  return {delegate, invoke, handleResponse}
 }

package/dist/utils/functions/child-runtime/step-history.d.ts

@@ -0,0 +1,15 @@
+import type {DurableStepEvent} from './types'
+
+type PendingRetry = {index: number; event: DurableStepEvent; delayMs: number}
+
+export function createStepHistory(): {
+  startRun: () => void
+  nextStep: () => {index: number; saved: DurableStepEvent | undefined}
+  recordSuccess: (index: number, event: DurableStepEvent) => void
+  recordFailure: (
+    index: number,
+    failure: {event: DurableStepEvent; error: unknown; delayMs: number},
+  ) => boolean
+  getPending: () => PendingRetry | null
+  settle: (pending: PendingRetry) => void
+}

package/dist/utils/functions/child-runtime/step-history.js

@@ -0,0 +1,52 @@
+const createStepHistory = () => {
+  const history = new Map([])
+  let cursor = 0
+  let pending = null
+
+  const startRun = () => {
+    cursor = 0
+  }
+
+  const nextStep = () => {
+    const index = cursor
+    cursor++
+    return {index, saved: history.get(index)}
+  }
+
+  const recordSuccess = (index, event) => {
+    history.set(index, event)
+  }
+
+  const recordFailure = (index, {event, error, delayMs}) => {
+    const retryable = event.attempt <= event.retries && error?.name !== 'UnrecoverableError'
+
+    if (retryable) {
+      history.set(index, {...event, output: error, retryDelayMs: delayMs})
+      pending = {index, event, delayMs}
+    } else {
+      history.set(index, {...event, output: error})
+    }
+    return retryable
+  }
+
+  const getPending = () => {
+    const item = pending
+    pending = null
+    return item
+  }
+
+  const settle = ({index, event}) => {
+    history.set(index, {...event, output: history.get(index).output})
+  }
+
+  return {
+    startRun,
+    nextStep,
+    recordSuccess,
+    recordFailure,
+    getPending,
+    settle,
+  }
+}
+
+export {createStepHistory}

package/dist/utils/functions/extract-durable-config.js

@@ -5,7 +5,7 @@ import { SANITY_FUNCTION_DURABLE } from '../../constants.js';
 import { isLocalFunctionResource } from '../types.js';
 import { findFunctionEntryPoint } from './find-entry-point.js';
 import { transpileFunction } from './transpile/function.js';
-const DURABLE_CONFIG_KEYS = ['event', 'concurrency', 'debounce', 'debounceKey'];
+const DURABLE_CONFIG_KEYS = ['event', 'concurrency', 'debounce'];
 /**
  * Extracts the blueprint config from the function source code and mutates it to the resource object.
  * This is used for durable functions that may not have a config defined in the blueprint.
@@ -47,9 +47,6 @@ export const extractDurableConfig = async (resource, blueprintFileDir) => {
     if (resource.debounce === undefined && config?.debounce !== undefined) {
         resource.debounce = config.debounce;
     }
-    if (resource.debounceKey === undefined && config?.debounceKey !== undefined) {
-        resource.debounceKey = config.debounceKey;
-    }
     // Validate the resource after merging the config values
     const errors = validateDurableFunction(resource);
     if (errors.length > 0) {

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

@@ -64,10 +64,11 @@ export default async function invoke(resource, payload, context, options) {
     // Apply the GROQ rule before preparing a build so a filtered-out event skips
     // the (potentially expensive) transpile entirely.
     if (isGroqInvocation(resource)) {
-        if (!isGroqContextOptions(context)) {
+        if (!('clientOptions' in context)) {
             throw new Error('GROQ-based functions require a context with clientOptions');
         }
-        const { projectId, dataset } = context.clientOptions;
+        const projectId = 'projectId' in context.clientOptions ? context.clientOptions.projectId : undefined;
+        const dataset = 'dataset' in context.clientOptions ? context.clientOptions.dataset : undefined;
         if ('before' in payload) {
             filteredData = await applyGroqRule(resource, payload, projectId, dataset);
             const filter = resource.event && 'filter' in resource.event ? resource.event.filter : '';
@@ -156,14 +157,14 @@ export default async function invoke(resource, payload, context, options) {
         // 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;
+            const { id, name, payload: nestedPayload, metadata } = 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);
+                const nested = await onNestedInvoke(name, nestedPayload ?? {}, context, depth + 1, callStack, metadata);
                 nestedTimings[`invoke:${name}`] =
                     (nestedTimings[`invoke:${name}`] ?? 0) + (performance.now() - nestedStart);
                 // Fire-and-forget contract: in production `context.invoke` returns once the
@@ -173,12 +174,22 @@ export default async function invoke(resource, payload, context, options) {
                 // 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 },
-                    };
+                    // step.delegate errors need to be surfaced to the caller for retry behavior and for the durable step to be marked as failed.
+                    const origin = metadata?.origin || undefined;
+                    const error = nested.error || undefined;
+                    const response = origin === 'step.delegate' && error
+                        ? {
+                            type: 'invoke-response',
+                            id,
+                            ok: false,
+                            error,
+                        }
+                        : {
+                            type: 'invoke-response',
+                            id,
+                            ok: true,
+                            result: { json: nested.json },
+                        };
                     child.send(JSON.stringify(response));
                 }
             }
@@ -231,7 +242,12 @@ export default async function invoke(resource, payload, context, options) {
                 }
                 // Nested invoke request — handle without tearing down the child.
                 if (msg?.type === 'invoke-request') {
-                    handleNestedInvoke({ id: msg.id, name: msg.name, payload: msg.payload });
+                    handleNestedInvoke({
+                        id: msg.id,
+                        name: msg.name,
+                        payload: msg.payload,
+                        metadata: msg.metadata,
+                    });
                     return;
                 }
                 // Terminal result message.

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

@@ -28,7 +28,7 @@ export function assertNestedInvokeAllowed(name, depth, callStack) {
  * stack extended by this function, and normalize timings.
  */
 export async function runFunction(resource, payload, context, options) {
-    const { forceColor, timeout, depth = 0, callStack = [], onNestedInvoke } = options;
+    const { forceColor, timeout, depth = 0, callStack = [], onNestedInvoke, onStepEvent } = options;
     assertNestedInvokeAllowed(resource.name, depth, callStack);
     const response = await invoke(resource, payload, context, {
         forceColor,
@@ -36,6 +36,7 @@ export async function runFunction(resource, payload, context, options) {
         onNestedInvoke,
         depth,
         callStack: [...callStack, resource.name],
+        onStepEvent,
     });
     return { ...response, timings: response.timings ?? {} };
 }

package/dist/utils/functions/invoke/resolve-invoke-type.d.ts

@@ -1,6 +1,6 @@
 import type { BlueprintResource } from '@sanity/blueprints';
 import type { Logger } from '../../logger.js';
-import type { EventType, FunctionGroqResource, FunctionResource, FunctionTestFlags, InvokeContextOptions, InvokePayloadOptions } from '../../types.js';
+import type { EventType, FunctionGroqResource, FunctionResource, FunctionTestFlags, InvokeContextOptions, InvokePayloadOptions, ResolvedResource } from '../../types.js';
 import buildPayload from '../build-payload.js';
 import { fetchAsset, fetchDocument } from '../fetch-document.js';
 export type InvocationPlan = {
@@ -23,7 +23,7 @@ export type InputContext = {
     apiHost: string;
     token?: string;
     withUserToken?: boolean;
-    resources: BlueprintResource[];
+    resolvedResources: ResolvedResource<BlueprintResource>[];
     blueprintFileDir: string;
     log: Logger;
 };

package/dist/utils/functions/invoke/resolve-invoke-type.js

@@ -51,7 +51,7 @@ export const buildContext = (plan, input) => {
     if (plan.kind === 'plain') {
         return {
             clientOptions: { ...withToken },
-            resources: input.resources,
+            resources: input.resolvedResources,
             blueprintFileDir: input.blueprintFileDir,
         };
     }
@@ -69,7 +69,7 @@ export const buildContext = (plan, input) => {
             '',
         functionResourceType: 'project',
         functionResourceId: input.projectId || '',
-        resources: input.resources,
+        resources: input.resolvedResources,
         blueprintFileDir: input.blueprintFileDir,
     };
 };

package/dist/utils/functions/transpile/function.js

@@ -37,6 +37,9 @@ export async function transpileFunction({ resource, functionPath, entryPoint, in
         const bundle = !!find.file('pnpm-workspace.yaml') || installer === 'pnpm';
         const result = await viteBuild({
             root: fnRootDir,
+            // Don't pick up the surrounding project's public/ folder or vite.config.*
+            publicDir: false,
+            configFile: false,
             logLevel: 'silent',
             build: {
                 target: 'node20',

package/dist/utils/types.d.ts

@@ -40,6 +40,11 @@ export interface BlueprintResourceRecord extends BlueprintResource {
 export interface DeployedResource extends BlueprintResourceRecord {
     externalId: string;
 }
+/** Wrap a resource and its externalId if it has one. */
+export interface ResolvedResource<R extends BlueprintResource> {
+    resource: R;
+    externalId?: string;
+}
 export declare function isLocalFunctionResource(r: BlueprintResource): r is FunctionResource;
 export declare function hasEventSource(r: FunctionResource): r is EventFunctionResource;
 export declare function isScheduleEvent(e: unknown): e is BlueprintScheduledFunctionResource['event'];
@@ -134,8 +139,14 @@ export type InvokePayloadMetadata = Pick<InvokeGroqPayloadOptions, 'event' | 'be
 export type EventType = 'create' | 'update' | 'delete';
 export type NonGroqEventType = 'plain' | 'nested' | 'durable';
 export declare function isEventType(arg: string): arg is EventType;
+interface BaseContextOptions {
+    /** All resources declared by the blueprint, used to populate `context.resources` at invoke time. */
+    resources?: ResolvedResource<BlueprintResource>[];
+    /** The directory where the blueprint manifest is located. */
+    blueprintFileDir: string;
+}
 /** @internal */
-export interface InvokeGroqContextOptions {
+export interface InvokeGroqContextOptions extends BaseContextOptions {
     clientOptions: {
         apiVersion?: string;
         dataset?: string;
@@ -151,20 +162,12 @@ export interface InvokeGroqContextOptions {
     functionResourceType: string;
     /** The resource ID of the function container; resource ID that houses the function. */
     functionResourceId: string;
-    /** All resources declared by the blueprint, used to populate `context.resources` at invoke time. */
-    resources?: BlueprintResource[];
-    /** The directory where the blueprint manifest is located. */
-    blueprintFileDir: string;
 }
 /** @internal */
-export interface InvokeScheduleContextOptions {
+export interface InvokeScheduleContextOptions extends BaseContextOptions {
     clientOptions: {
         token?: string;
     };
-    /** All resources declared by the blueprint, used to populate `context.resources` at invoke time. */
-    resources?: BlueprintResource[];
-    /** The directory where the blueprint manifest is located. */
-    blueprintFileDir: string;
 }
 export type InvokeContextOptions = InvokeGroqContextOptions | InvokeScheduleContextOptions;
 export declare function isGroqContextOptions(context: InvokeContextOptions): context is InvokeGroqContextOptions;
@@ -187,12 +190,15 @@ export interface InvokeExecutionOptions {
     /** Don't wait the full duration during a wait durable event @internal */
     noWait?: boolean;
 }
+export type NestedInvokeMetadata = {
+    origin?: 'step.delegate';
+};
 /**
  * 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 & {
+export type NestedInvoke = (name: string, payload: Record<string, unknown>, context: InvokeContextOptions, depth: number, callStack: string[], metadata?: NestedInvokeMetadata) => Promise<InvocationResponse & {
     timings: Record<string, number>;
 }>;
 /**
@@ -233,6 +239,7 @@ export type ChildToParentMessage = {
     name: string;
     payload: Record<string, unknown>;
     isDurable?: boolean;
+    metadata?: NestedInvokeMetadata;
 } | {
     type: 'result';
     json?: JsonInvocationResponse;
@@ -334,7 +341,7 @@ export type AssetPrepResult = {
     error: string;
 };
 export type PrepAssetFn<R extends BlueprintResource> = (options: {
-    resource: R;
+    resolvedResource: ResolvedResource<R>;
     blueprintFileDir: string;
     installer?: InstallerType;
 }) => Promise<AssetPrepResult>;
@@ -351,7 +358,7 @@ export type PreDeployConfig = {
     prepareResource?: PrepResourceFn<BlueprintResource>;
 };
 export type AssetResource<R extends BlueprintResource> = {
-    resource: R;
+    resource: ResolvedResource<R>;
     prepareAsset: PrepAssetFn<R>;
 };
 export type Warning = {
@@ -372,6 +379,10 @@ export interface DurableStepEvent {
     output?: unknown;
     error?: InvocationError;
     durationMs?: number;
+    retryDelayMs?: number;
+    attempt?: number;
+    retries?: number;
+    maxAttempts?: number;
 }
 export interface DurableLogEvent {
     kind: 'log';

package/dist/utils/types.js

@@ -38,7 +38,7 @@ export function isEventType(arg) {
     return ['create', 'update', 'delete'].includes(arg);
 }
 export function isGroqContextOptions(context) {
-    return 'clientOptions' in context;
+    return 'eventResourceType' in context;
 }
 /** @internal */
 export var BlueprintParserErrorType;

package/oclif.manifest.json

@@ -3148,5 +3148,5 @@
       ]
     }
   },
-  "version": "17.15.0"
+  "version": "17.16.0-next.g05d3b7f"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "17.15.0",
+  "version": "17.16.0-next.g05d3b7f",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -68,7 +68,7 @@
     "@oclif/core": "^4.14.0",
     "@oclif/plugin-help": "^6.3.0",
     "@sanity-labs/oclif-plugin-skills-flag": "^0.2.1",
-    "@sanity/blueprints": "^0.27.0",
+    "@sanity/blueprints": "^0.28.0",
     "@sanity/blueprints-parser": "^0.5.0",
     "@sanity/cli-build": "^6.3.0",
     "@sanity/cli-core": "^3.7.0",
@@ -100,7 +100,7 @@
     "@oclif/test": "^4.2.0",
     "@playwright/test": "^1.63.0",
     "@sanity-labs/design-tokens": "^0.0.2-alpha.2",
-    "@sanity/functions": "^1.7.2",
+    "@sanity/functions": "^1.10.1",
     "@types/cardinal": "^2.1.1",
     "@types/mime-types": "^3.0.1",
     "@types/node": "^22",

package/dist/actions/blueprints/resolve.d.ts

@@ -1,51 +0,0 @@
-import type { ScopeType } from '../../utils/types.js';
-/**
- * Source of a resolved config value.
- * - flags: from CLI flags like `--project-id`
- * - env: from the environment - usually CLI var like `SANITY_ORGANIZATION_ID`
- * - module: from the blueprint module - undocumented escape hatch
- * - config: from the config file - .sanity/blueprint.config.json most common
- * - inferred: legacy `ST-<projectId>` stacks from launch
- */
-export type ConfigSource = 'flags' | 'env' | 'module' | 'config' | 'inferred';
-/** A set of optional IDs from a single source. */
-export interface IdValues {
-    organizationId?: string;
-    projectId?: string;
-    stackId?: string;
-}
-/**
- * Sources to resolve IDs from, in descending priority.
- * Each key maps to a source; the first non-empty value wins.
- *
- * - `env` defaults to reading SANITY_* process.env vars
- * - `module` and `config` accept any object with `{organizationId?, projectId?, stackId?}`
- */
-export interface IdSources {
-    flags?: IdValues | null;
-    env?: IdValues | null;
-    module?: IdValues | null;
-    config?: IdValues | null;
-}
-export interface ResolvedIds {
-    organizationId?: string;
-    projectId?: string;
-    stackId?: string;
-    scopeType?: ScopeType;
-    scopeId?: string;
-    sources: {
-        organizationId?: ConfigSource;
-        projectId?: ConfigSource;
-        stackId?: ConfigSource;
-    };
-}
-/**
- * Resolve organization, project, and stack IDs from a prioritized set of sources.
- * Precedence: flags > env > module > config.
- * Derives scopeType/scopeId from the resolved IDs (project > organization).
- *
- * Env vars are read from process.env by default (SANITY_ORGANIZATION_ID,
- * SANITY_PROJECT_ID, SANITY_BLUEPRINT_STACK_ID). Pass `env` explicitly to
- * override, or `null` to skip.
- */
-export declare function resolveIds(sources?: IdSources): ResolvedIds;

package/dist/actions/blueprints/resolve.js

@@ -1,52 +0,0 @@
-import { env as processEnv } from 'node:process';
-/**
- * Resolve organization, project, and stack IDs from a prioritized set of sources.
- * Precedence: flags > env > module > config.
- * Derives scopeType/scopeId from the resolved IDs (project > organization).
- *
- * Env vars are read from process.env by default (SANITY_ORGANIZATION_ID,
- * SANITY_PROJECT_ID, SANITY_BLUEPRINT_STACK_ID). Pass `env` explicitly to
- * override, or `null` to skip.
- */
-export function resolveIds(sources = {}) {
-    const envValues = sources.env !== undefined
-        ? sources.env
-        : {
-            organizationId: processEnv.SANITY_ORGANIZATION_ID,
-            projectId: processEnv.SANITY_PROJECT_ID,
-            stackId: processEnv.SANITY_BLUEPRINT_STACK_ID,
-        };
-    const ordered = [
-        { source: 'flags', values: sources.flags },
-        { source: 'env', values: envValues },
-        { source: 'module', values: sources.module },
-        { source: 'config', values: sources.config },
-    ];
-    const result = { sources: {} };
-    for (const { source, values } of ordered) {
-        if (values === null || values === undefined)
-            continue;
-        if (!result.organizationId && values.organizationId) {
-            result.organizationId = values.organizationId;
-            result.sources.organizationId = source;
-        }
-        if (!result.projectId && values.projectId) {
-            result.projectId = values.projectId;
-            result.sources.projectId = source;
-        }
-        if (!result.stackId && values.stackId) {
-            result.stackId = values.stackId;
-            result.sources.stackId = source;
-        }
-    }
-    // Scope is as specific as possible; project > organization
-    if (result.projectId) {
-        result.scopeType = 'project';
-        result.scopeId = result.projectId;
-    }
-    else if (result.organizationId) {
-        result.scopeType = 'organization';
-        result.scopeId = result.organizationId;
-    }
-    return result;
-}