@sanity/runtime-cli 17.8.0 → 17.9.0

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/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-runtime/durable.js

@@ -39,7 +39,7 @@ export async function runDurable(handler, {context, event, logger}, io) {
   }
 
   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})),
   }
 
   return handler({context, event, step, logger})

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

@@ -9,6 +9,7 @@ import { SANITY_FUNCTION_DURABLE } from '../../../constants.js';
 import { groupBlueprintResources } from '../../blueprints/group-resources.js';
 import { isGroqContextOptions, } from '../../types.js';
 import { acquireFunctionBuild } from './prepare.js';
+import { isGroqInvocation } from './resolve-invoke-type.js';
 function getChildProcessWrapperPath() {
     return fileURLToPath(new URL('../child-process-wrapper.js', import.meta.url));
 }
@@ -17,13 +18,16 @@ export function sanitizeLogs(logs) {
 }
 export async function applyGroqRule(resource, payload, projectId, dataset) {
     const { before, after, payload: data = null } = payload;
+    const event = resource.event;
     // If there is no rule set return everything
-    if (!resource.event)
+    if (!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 || ''}`;
+    const filter = 'filter' in event ? event.filter : undefined;
+    const projection = 'projection' in event ? event.projection : undefined;
+    if (filter || projection) {
+        const query = `*[${filter || ''}]${projection || ''}`;
         try {
             const rule = groq.parse(query, { mode: 'delta' });
             const sanity = projectId && dataset ? { projectId, dataset } : undefined;
@@ -44,20 +48,23 @@ 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 = () => { }, } = options;
+    // `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).
+    let filteredData = payload?.payload || {};
     // 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 (isGroqInvocation(resource)) {
         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);
+            const filter = resource.event && 'filter' in resource.event ? resource.event.filter : '';
             if (typeof filteredData === 'undefined') {
                 return {
-                    logs: `⚠️ Filter "${resource.event?.filter}" returned an empty result. Skipping invoke.`,
+                    logs: `⚠️ Filter "${filter}" returned an empty result. Skipping invoke.`,
                     error: undefined,
                     json: undefined,
                 };

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

@@ -0,0 +1,51 @@
+import type { BlueprintResource } from '@sanity/blueprints';
+import type { Logger } from '../../logger.js';
+import type { EventType, FunctionGroqResource, FunctionResource, FunctionTestFlags, InvokeContextOptions, InvokePayloadOptions } from '../../types.js';
+import buildPayload from '../build-payload.js';
+import { fetchAsset, fetchDocument } from '../fetch-document.js';
+export type InvocationPlan = {
+    kind: 'groq';
+    inputSource: 'document' | 'media';
+    isDurable: boolean;
+} | {
+    kind: 'plain';
+    isDurable: false;
+} | {
+    kind: 'durable';
+    inputSource: 'payload';
+    isDurable: true;
+};
+export type InputContext = {
+    flags: FunctionTestFlags;
+    projectId?: string;
+    organizationId?: string;
+    api?: string;
+    apiHost: string;
+    token?: string;
+    withUserToken?: boolean;
+    resources: BlueprintResource[];
+    blueprintFileDir: string;
+    log: Logger;
+};
+type InvocationDeps = {
+    fetchDocument: typeof fetchDocument;
+    fetchAsset: typeof fetchAsset;
+    buildPayload: typeof buildPayload;
+};
+export declare const defaultInvocationDeps: InvocationDeps;
+export interface InvokeInput {
+    payload: Record<string, unknown>;
+    before: Record<string, unknown> | null;
+    after: Record<string, unknown> | null;
+}
+export declare const resolveInvocationPlan: (resource: FunctionResource) => InvocationPlan;
+/**
+ * True when the function's event is delivered through a GROQ rule (a document or
+ * media-library event, whether plain or durable), so its payload is a document the
+ * rule may narrow before the handler sees it.
+ */
+export declare const isGroqInvocation: (resource: FunctionResource) => resource is FunctionGroqResource;
+export declare const collectInvokeInput: (plan: InvocationPlan, input: InputContext, deps: InvocationDeps) => Promise<InvokeInput>;
+export declare const buildContext: (plan: InvocationPlan, input: InputContext) => InvokeContextOptions;
+export declare const buildInvokeOptions: (plan: InvocationPlan, invokeInput: InvokeInput, eventType: EventType) => InvokePayloadOptions;
+export {};

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

@@ -0,0 +1,131 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../../constants.js';
+import { parseJsonObject } from '../../parse-json-object.js';
+import buildPayload from '../build-payload.js';
+import { fetchAsset, fetchDocument } from '../fetch-document.js';
+export const defaultInvocationDeps = { fetchDocument, fetchAsset, buildPayload };
+const assertNever = (resource) => {
+    throw new Error(`No invocation plan for function type: ${resource.type}`);
+};
+const resolveDurableInvocationPlan = (event) => {
+    switch (event?.type) {
+        case 'document':
+            return { kind: 'groq', inputSource: 'document', isDurable: true };
+        case 'media-library':
+            return { kind: 'groq', inputSource: 'media', isDurable: true };
+        case 'sync-tag-invalidate':
+        case undefined:
+            return { kind: 'durable', inputSource: 'payload', isDurable: true };
+    }
+};
+export const resolveInvocationPlan = (resource) => {
+    switch (resource.type) {
+        case SANITY_FUNCTION_DOCUMENT:
+            return { kind: 'groq', inputSource: 'document', isDurable: false };
+        case SANITY_FUNCTION_MEDIA_LIBRARY_ASSET:
+            return { kind: 'groq', inputSource: 'media', isDurable: false };
+        case SANITY_FUNCTION_DURABLE:
+            return resolveDurableInvocationPlan(resource.event);
+        case SANITY_FUNCTION_SCHEDULED:
+        case SANITY_FUNCTION_PUBSUB:
+        case SANITY_FUNCTION_SYNC_TAG_INVALIDATE:
+            return { kind: 'plain', isDurable: false };
+        default:
+            return assertNever(resource);
+    }
+};
+/**
+ * True when the function's event is delivered through a GROQ rule (a document or
+ * media-library event, whether plain or durable), so its payload is a document the
+ * rule may narrow before the handler sees it.
+ */
+export const isGroqInvocation = (resource) => resolveInvocationPlan(resource).kind === 'groq';
+export const collectInvokeInput = async (plan, input, deps) => {
+    const source = plan.kind === 'groq' ? plan.inputSource : 'none';
+    return resolveInvokeInput(source, input, deps);
+};
+export const buildContext = (plan, input) => {
+    const withToken = input.withUserToken ? { token: input.token } : {};
+    if (plan.kind === 'plain') {
+        return {
+            clientOptions: { ...withToken },
+            resources: input.resources,
+            blueprintFileDir: input.blueprintFileDir,
+        };
+    }
+    const isMedia = plan.kind === 'groq' && plan.inputSource === 'media';
+    return {
+        clientOptions: {
+            apiVersion: input.api,
+            dataset: input.flags.dataset,
+            projectId: input.projectId,
+            organizationId: input.organizationId,
+            ...withToken,
+        },
+        eventResourceType: isMedia ? 'media-library' : 'dataset',
+        eventResourceId: (isMedia ? input.flags['media-library-id'] : `${input.projectId}.${input.flags.dataset}`) ||
+            '',
+        functionResourceType: 'project',
+        functionResourceId: input.projectId || '',
+        resources: input.resources,
+        blueprintFileDir: input.blueprintFileDir,
+    };
+};
+export const buildInvokeOptions = (plan, invokeInput, eventType) => {
+    switch (plan.kind) {
+        case 'groq':
+            return {
+                event: eventType,
+                payload: invokeInput.payload,
+                before: invokeInput.before,
+                after: invokeInput.after,
+            };
+        case 'plain':
+            // Cron functions have no payload, but pubsub and sync-tag-invalidate carry
+            // whatever the producer sent, so pass it through for all of them.
+            return { event: 'plain', payload: invokeInput.payload };
+        case 'durable':
+            return { event: 'durable', payload: invokeInput.payload };
+    }
+};
+const resolveInvokeInput = async (source, input, deps) => {
+    const { flags } = input;
+    const fetchById = (id) => source === 'document'
+        ? deps.fetchDocument(id, {
+            projectId: input.projectId,
+            dataset: flags.dataset,
+            apiVersion: input.api,
+            apiHost: input.apiHost,
+            token: input.token,
+        }, input.log)
+        : deps.fetchAsset(id, {
+            mediaLibraryId: flags['media-library-id'],
+            apiVersion: input.api,
+            apiHost: input.apiHost,
+            token: input.token,
+        }, input.log);
+    let before = null;
+    let after = null;
+    if (flags['data-before'] && flags['data-after']) {
+        before = parseJsonObject(flags['data-before']);
+        after = parseJsonObject(flags['data-after']);
+    }
+    else if (flags['file-before'] && flags['file-after']) {
+        before = parseJsonObject(readFileSync(join(cwd(), flags['file-before']), 'utf8'));
+        after = parseJsonObject(readFileSync(join(cwd(), flags['file-after']), 'utf8'));
+    }
+    else if (flags['document-id-before'] && flags['document-id-after']) {
+        before = await fetchById(flags['document-id-before']);
+        after = await fetchById(flags['document-id-after']);
+    }
+    let payload;
+    if (after)
+        payload = after;
+    else if (flags['document-id'])
+        payload = await fetchById(flags['document-id']);
+    else
+        payload = deps.buildPayload({ data: flags.data, file: flags.file });
+    return { payload, before, after };
+};

package/dist/utils/types.d.ts

@@ -14,7 +14,7 @@ export interface ActionResponse {
     error: string | null;
 }
 /** @internal */
-export type FunctionGroqResource = BlueprintDocumentFunctionResource | BlueprintMediaLibraryAssetFunctionResource;
+export type FunctionGroqResource = BlueprintDocumentFunctionResource | BlueprintMediaLibraryAssetFunctionResource | BlueprintDurableFunctionResource;
 export type FunctionResource = FunctionGroqResource | BlueprintPubSubFunctionResource | BlueprintScheduledFunctionResource | BlueprintSyncTagInvalidateFunctionResource | BlueprintDurableFunctionResource;
 /** Function resources that declare an `event`; PubSub functions are triggered by other functions */
 export type EventFunctionResource = Exclude<FunctionResource, BlueprintPubSubFunctionResource>;
@@ -111,7 +111,7 @@ export interface InvokeNonGroqPayloadOptions {
 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' | 'durable';
+export type NonGroqEventType = 'plain' | 'nested' | 'durable';
 export declare function isEventType(arg: string): arg is EventType;
 /** @internal */
 export interface InvokeGroqContextOptions {
@@ -315,4 +315,23 @@ export interface DurableStepEvent {
     error?: InvocationError;
     durationMs?: number;
 }
+export interface FunctionTestFlags {
+    data?: string;
+    event?: string;
+    file?: string;
+    timeout?: number;
+    api?: string;
+    dataset?: string;
+    'project-id'?: string;
+    'organization-id'?: string;
+    'document-id'?: string;
+    'with-user-token'?: boolean;
+    'data-before'?: string;
+    'data-after'?: string;
+    'file-before'?: string;
+    'file-after'?: string;
+    'document-id-before'?: string;
+    'document-id-after'?: string;
+    'media-library-id'?: string;
+}
 export {};

package/oclif.manifest.json

@@ -1556,9 +1556,10 @@
     "blueprints:stacks": {
       "aliases": [],
       "args": {},
-      "description": "Shows all Stacks associated with a project or organization. By default, lists Stacks scoped to the local Blueprint.\n\nUse this to discover existing Stacks you can scope a local Blueprint to (using 'blueprints config --edit'), or to audit what's deployed across your project.\n\nUse --include-projects with --organization-id to also list Stacks from all projects within the organization.",
+      "description": "Shows all Stacks associated with a project or organization. By default, lists Stacks scoped to the local Blueprint.\n\nUse this to discover existing Stacks you can scope a local Blueprint to (using 'blueprints config --edit'), or to audit what's deployed across your project.\n\nWithout a scope, prompts for an organization or project. Use --all to list Stacks across every organization and project you can access, or --include-projects with --organization-id for one organization and its projects.",
       "examples": [
         "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> --all",
         "<%= config.bin %> <%= command.id %> --project-id <projectId>",
         "<%= config.bin %> <%= command.id %> --organization-id <organizationId>",
         "<%= config.bin %> <%= command.id %> --organization-id <organizationId> --include-projects"
@@ -1620,7 +1621,8 @@
           "description": "Sanity project ID used to scope Blueprint and Stack",
           "exclusive": [
             "organization-id",
-            "include-projects"
+            "include-projects",
+            "all"
           ],
           "name": "project-id",
           "hasDynamicHelp": false,
@@ -1635,7 +1637,8 @@
           ],
           "description": "Sanity organization ID used to scope Blueprint and Stack",
           "exclusive": [
-            "project-id"
+            "project-id",
+            "all"
           ],
           "name": "organization-id",
           "hasDynamicHelp": false,
@@ -1650,6 +1653,17 @@
           "name": "include-projects",
           "allowNo": false,
           "type": "boolean"
+        },
+        "all": {
+          "description": "List Stacks from every organization and project you have access to",
+          "exclusive": [
+            "project-id",
+            "organization-id",
+            "include-projects"
+          ],
+          "name": "all",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -1662,7 +1676,7 @@
       "summary": "List remote Stack deployments for your project or organization",
       "enableJsonFlag": true,
       "needs": [
-        "scope"
+        "token"
       ],
       "isESM": true,
       "relativePath": [
@@ -3127,5 +3141,5 @@
       ]
     }
   },
-  "version": "17.8.0"
+  "version": "17.9.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "17.8.0",
+  "version": "17.9.0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",

package/skills/blueprints-stacks.md

@@ -17,7 +17,9 @@ npx @sanity/cli blueprints stacks --project-id PROJECT_ID --json
 npx @sanity/cli blueprints stacks --organization-id ORGANIZATION_ID --json
 ```
 
-The JSON result contains `stacks`, `scopeType`, and `scopeId`; each entry carries `resourceCount` rather than a full `resources` array. Zero results prints `No stacks found` and emits no JSON. Match both the Stack and its scope; names alone may be ambiguous.
+Always pass a scope flag or `--all` when automating. With no scope to resolve the command prompts for an organization, then for a project if you pick project scope; without a terminal, or with `--json`, it fails with a missing-scope error instead.
+
+The JSON result contains `stacks`, `scopeType`, and `scopeId`; each entry carries `resourceCount` rather than a full `resources` array. Zero results prints `No stacks found`, and under `--json` returns an empty `stacks` array. Match both the Stack and its scope; names alone may be ambiguous.
 
 To also include Stacks scoped to the organization's projects:
 
@@ -25,4 +27,14 @@ To also include Stacks scoped to the organization's projects:
 npx @sanity/cli blueprints stacks --organization-id ORGANIZATION_ID --include-projects --json
 ```
 
-`--include-projects` requires `--organization-id`, cannot be combined with `--project-id`, and only queries the organization's first 50 projects. This command does not change the local Blueprint target; use `blueprints config --edit` for that.
+`--include-projects` requires `--organization-id`, cannot be combined with `--project-id`, and only queries the organization's first 50 projects.
+
+To sweep every organization and project the token can reach:
+
+```sh
+npx @sanity/cli blueprints stacks --all --json
+```
+
+`--all` cannot be combined with the scope flags or `--include-projects`. It is best effort: scopes that return an error are skipped and reported as a count, and only the first 200 projects are queried. Its JSON result contains `stacks` and no top-level `scopeType`/`scopeId`; read each entry's own `scopeType` and `scopeId` instead.
+
+This command does not change the local Blueprint target; use `blueprints config --edit` for that.