@sanity/runtime-cli 17.4.0 → 17.6.0-blueprinit.g77b7a64

package/dist/cores/blueprinit/selection.js

@@ -0,0 +1,90 @@
+import { select } from '@inquirer/prompts';
+export async function chooseOrganization(groups, organizationId, interactive) {
+    if (groups.length === 0) {
+        return failure('No organizations found for this account.');
+    }
+    if (organizationId) {
+        const organization = groups.find((group) => group.organization.id === organizationId);
+        return organization
+            ? { ok: true, value: organization }
+            : failure(`No organization "${organizationId}" found for this account.`);
+    }
+    if (groups.length === 1)
+        return { ok: true, value: groups[0] };
+    if (!interactive) {
+        return failure('Multiple organizations found.', ['Pass --organization-id <id> to choose one.']);
+    }
+    const selectedId = await select({
+        message: 'Choose a Sanity organization:',
+        choices: groups.map(({ organization, projects }) => ({
+            name: organization.name,
+            value: organization.id,
+            description: `${projects?.length ?? 0} projects`,
+        })),
+    });
+    const selected = groups.find(({ organization }) => organization.id === selectedId);
+    return selected ? { ok: true, value: selected } : failure('Organization not found.');
+}
+export async function chooseProject(projects, projectId, organizationName, interactive) {
+    if (projects.length === 0) {
+        return failure(`No projects found in ${organizationName}.`);
+    }
+    if (projectId) {
+        const project = projects.find(({ id }) => id === projectId);
+        return project
+            ? { ok: true, value: project }
+            : failure(`No project "${projectId}" found in ${organizationName}.`);
+    }
+    if (projects.length === 1)
+        return { ok: true, value: projects[0] };
+    if (!interactive) {
+        return failure('Multiple projects found.', ['Pass --project-id <id> to choose one.']);
+    }
+    const selectedId = await select({
+        message: 'Choose a Sanity project:',
+        choices: projects.map((project) => ({ name: project.displayName, value: project.id })),
+    });
+    const selected = projects.find(({ id }) => id === selectedId);
+    return selected ? { ok: true, value: selected } : failure('Project not found.');
+}
+export async function chooseDataset(datasets, datasetName, projectName, interactive) {
+    if (datasets.length === 0) {
+        return failure(`No datasets found in ${projectName}.`);
+    }
+    if (datasetName) {
+        const dataset = datasets.find(({ name }) => name === datasetName);
+        return dataset
+            ? { ok: true, value: dataset }
+            : failure(`No dataset "${datasetName}" found in ${projectName}.`);
+    }
+    if (datasets.length === 1)
+        return { ok: true, value: datasets[0] };
+    if (!interactive) {
+        return failure('Multiple datasets found.', ['Pass --dataset <name> to choose one.']);
+    }
+    const production = datasets.find(({ name }) => name === 'production');
+    const orderedDatasets = production
+        ? [production, ...datasets.filter(({ name }) => name !== 'production')]
+        : datasets;
+    const selectedName = await select({
+        message: 'Choose a Sanity dataset:',
+        choices: orderedDatasets.map((dataset) => ({
+            name: dataset.name,
+            value: dataset.name,
+            description: dataset.aclMode,
+        })),
+    });
+    const selected = datasets.find(({ name }) => name === selectedName);
+    return selected ? { ok: true, value: selected } : failure('Dataset not found.');
+}
+export function findProject(groups, projectId) {
+    for (const { organization, projects = [] } of groups) {
+        const project = projects.find(({ id }) => id === projectId);
+        if (project)
+            return { organization, project };
+    }
+    return undefined;
+}
+function failure(message, suggestions) {
+    return { ok: false, error: { message, suggestions } };
+}

package/dist/cores/blueprinit/types.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '../../utils/logger.js';
+export interface BlueprinitFlags {
+    yes?: boolean;
+    organizationId?: string;
+    projectId?: string;
+    datasetName?: string;
+    stackName?: string;
+    studioName?: string;
+}
+export interface BlueprinitFlowOptions {
+    bin: string;
+    dir: string;
+    flags: BlueprinitFlags;
+    log: Logger;
+    token: string;
+}

package/dist/cores/blueprinit/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cores/blueprinit.d.ts

@@ -0,0 +1,7 @@
+import type { BlueprinitFlags } from './blueprinit/types.js';
+import type { CoreConfig, CoreResult } from './index.js';
+export interface BlueprinitOptions extends CoreConfig {
+    dir?: string;
+    flags?: BlueprinitFlags;
+}
+export declare function blueprinitCore(options: BlueprinitOptions): Promise<CoreResult>;

package/dist/cores/blueprinit.js

@@ -0,0 +1,48 @@
+import { cwd } from 'node:process';
+import { detectStudio } from '../actions/blueprinit/studio.js';
+import { findBlueprintFile } from '../actions/blueprints/blueprint.js';
+import { readConfigFile } from '../actions/blueprints/config.js';
+import { validTokenOrErrorMessage } from '../utils/validated-token.js';
+import { adoptFlow } from './blueprinit/adopt.js';
+import { freshFlow } from './blueprinit/fresh.js';
+export async function blueprinitCore(options) {
+    const { bin, log, flags = {}, dir = cwd() } = options;
+    try {
+        const existingBlueprint = findBlueprintFile(dir);
+        if (existingBlueprint) {
+            const blueprintConfig = readConfigFile(existingBlueprint.blueprintFilePath);
+            if (!blueprintConfig?.stackId) {
+                return {
+                    success: false,
+                    error: `A Blueprint exists here (${existingBlueprint.fileName}), but it is not connected to a Stack.`,
+                    suggestions: [`Finish setup with: npx ${bin} blueprints init`],
+                };
+            }
+            log(`A blueprint already exists here (${existingBlueprint.fileName}).`);
+            log('');
+            log('Use these instead:');
+            log(`  npx ${bin} blueprints config --edit`);
+            log(`  npx ${bin} blueprints doctor`);
+            return {
+                success: true,
+                json: { alreadyInitialized: true, blueprintFile: existingBlueprint.fileName },
+            };
+        }
+        const tokenCheck = await validTokenOrErrorMessage(log);
+        if (!tokenCheck.ok) {
+            return {
+                success: false,
+                error: 'No Sanity session found.',
+                suggestions: ['Sign in first: npx sanity login', 'Then run init again.'],
+            };
+        }
+        log('Setting up your Sanity workspace.');
+        log('');
+        const flowOptions = { bin, dir, flags, log, token: tokenCheck.value };
+        const studio = detectStudio(dir);
+        return studio ? await adoptFlow({ ...flowOptions, studio }) : await freshFlow(flowOptions);
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/cores/blueprints/deploy.js

@@ -3,22 +3,23 @@ import { preDeploy } from '../../actions/blueprints/pre-deploy.js';
 import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
 import { waitForOperation } from '../../actions/blueprints/wait-for-operation.js';
 import { checkUserPermission } from '../../actions/sanity/access.js';
+import { extractDurableConfig } from '../../utils/blueprints/extract-durable-config.js';
 import { createHintCollector } from '../../utils/blueprints/hints.js';
-import { niceId } from '../../utils/display/presenters.js';
+import { check, niceId, severe } from '../../utils/display/presenters.js';
 import { CODE_OPERATION_UNCONFIRMED, EXIT_OPERATION_UNCONFIRMED } from '../../utils/exit-codes.js';
 import { styleText } from '../../utils/style-text.js';
 import { getWarnings } from '../../utils/warnings.js';
 export async function blueprintDeployCore(options) {
-    const { bin = 'sanity', log, auth, stackId, scopeType, scopeId, deployedStack, blueprint, flags, } = options;
+    const { bin = 'sanity', log: logger, auth, stackId, scopeType, scopeId, deployedStack, blueprint, flags, } = options;
     const { verbose } = flags;
     const noWait = flags['no-wait'] || false;
     const stackName = flags['new-stack-name'] ?? deployedStack.name;
     const installer = flags['fn-installer'] || undefined;
     const blueprintFileDir = dirname(blueprint.fileInfo.blueprintFilePath);
     const workspaceWarnings = getWarnings({ dir: blueprintFileDir });
-    log(`Deploying "${stackName}" ${niceId(deployedStack.id)}...`);
+    logger(`Deploying "${stackName}" ${niceId(deployedStack.id)}...`);
     try {
-        const { ok: checkOk, stack: currentStack } = await getStack({ stackId, auth, logger: log });
+        const { ok: checkOk, stack: currentStack } = await getStack({ stackId, auth, logger });
         if (!checkOk) {
             return { success: false, error: 'Failed to check current Stack status' };
         }
@@ -34,23 +35,24 @@ export async function blueprintDeployCore(options) {
             };
         }
         const resources = [...blueprint.resources];
+        await extractDurableConfig(resources, blueprintFileDir);
         const preDeployResult = await preDeploy({
             scopeType,
             scopeId,
-            resources,
+            resources, // mutated by preDeploy
             stackId,
             stackName,
             auth,
             blueprintFileDir,
             installer,
-            log,
+            logger,
             bin,
             verbose,
+            onAssetEvent: createAssetEventHandler(logger),
         });
-        if (!preDeployResult?.success) {
+        if (!preDeployResult?.success)
             return preDeployResult;
-        }
-        const spinner = log.ora('Deploying...').start();
+        const deploySpinner = logger.ora('Deploying...').start();
         const { ok: deployOk, stack, error: deployError, } = await updateStack({
             stackId,
             stackMutation: {
@@ -61,10 +63,10 @@ export async function blueprintDeployCore(options) {
                 userMessage: flags.message,
             },
             auth,
-            logger: log,
+            logger,
         });
         if (!deployOk) {
-            spinner.fail(`${styleText('red', 'Failed')} to update Stack deployment`);
+            deploySpinner.fail(`${styleText('red', 'Failed')} to update Stack deployment`);
             const hints = createHintCollector(bin);
             if (deployError) {
                 hints.inspectMessage(deployError);
@@ -79,18 +81,18 @@ export async function blueprintDeployCore(options) {
                 ],
             };
         }
-        spinner.stop().clear();
+        deploySpinner.stop().clear();
         const legacyPermissionsNoticePromise = CHECK_LEGACY_DEPLOY_PERMISSION
             ? checkLegacyDeployPermission({
                 auth,
                 scopeType,
                 scopeId,
-                log,
+                log: logger,
             })
             : Promise.resolve(null);
         if (noWait) {
-            log(styleText(['bold', 'green'], 'Stack deployment started!'));
-            log(`Use \`npx ${bin} blueprints info\` to check status`);
+            logger(styleText(['bold', 'green'], 'Stack deployment started!'));
+            logger(`Use \`npx ${bin} blueprints info\` to check status`);
             const legacyWarning = await legacyPermissionsNoticePromise;
             const warnings = [...(legacyWarning ? [legacyWarning] : []), ...workspaceWarnings];
             return {
@@ -100,19 +102,19 @@ export async function blueprintDeployCore(options) {
                 warnings: warnings.length ? warnings : undefined,
             };
         }
-        log(styleText('dim', 'Stack deployment progress:'));
-        log('');
+        logger(styleText('dim', 'Stack deployment progress:'));
+        logger('');
         const outcome = await waitForOperation({
             stackId,
             operationId: stack.operationId,
             auth,
-            log,
+            log: logger,
             bin,
             verbose,
             progressNoun: 'deployment',
         });
         if (outcome.type === 'completed') {
-            log(styleText(['bold', 'green'], 'Stack deployment completed!'));
+            logger(styleText(['bold', 'green'], 'Stack deployment completed!'));
             const legacyWarning = await legacyPermissionsNoticePromise;
             const warnings = [...(legacyWarning ? [legacyWarning] : []), ...workspaceWarnings];
             return {
@@ -151,6 +153,56 @@ export async function blueprintDeployCore(options) {
         return { success: false, error: errorMessage };
     }
 }
+function createAssetEventHandler(logger) {
+    let spinner;
+    const results = [];
+    return (event) => {
+        switch (event.type) {
+            case 'progress': {
+                const { completed, total, slow } = event.progress;
+                const text = [
+                    `Processing assets (${completed}/${total})`,
+                    slow ? ', this can take a moment' : '',
+                ].join('');
+                if (spinner)
+                    spinner.text = text;
+                else
+                    spinner = logger.ora(text).start();
+                return;
+            }
+            case 'result': {
+                results.push(event.result);
+                return;
+            }
+            case 'complete': {
+                spinner?.stop();
+                spinner = undefined;
+                break;
+            }
+        }
+        // done. print report
+        for (const result of results) {
+            const { resource } = result;
+            if (!result.success) {
+                const summary = result.failureKind === 'upload'
+                    ? `Failed uploading ${resource.name} asset`
+                    : `Failed processing ${resource.name} asset`;
+                logger(` ${severe(summary)}`);
+                logger.error(`   ${result.error}`);
+                continue;
+            }
+            logger(` ${check(`${resource.name} ${niceId(resource.src)}`)}`);
+            logger(`   Source: ${resource.src}`);
+            if (result.hash) {
+                const hash = result.hash;
+                const h = hash.length > 24 ? `${hash.slice(0, 8)}...${hash.slice(-12)}` : hash;
+                logger.verbose(`   Hash: ${h}`);
+            }
+            if (result.exists)
+                logger.verbose('   Asset unchanged');
+        }
+    };
+}
 const CHECK_LEGACY_DEPLOY_PERMISSION = false;
 const BLUEPRINTS_PERMISSION_ENFORCEMENT_DATE = 'July 1, 2026';
 async function checkLegacyDeployPermission({ auth, scopeType, scopeId, log, }) {

package/dist/cores/blueprints/plan.js

@@ -1,5 +1,6 @@
 import { dirname } from 'node:path';
 import { planStack, resolveStackIdByNameOrId } from '../../actions/blueprints/stacks.js';
+import { extractDurableConfig } from '../../utils/blueprints/extract-durable-config.js';
 import { createHintCollector } from '../../utils/blueprints/hints.js';
 import { formatDeploymentPlan, formatResourceTree, hasActionableChanges, } from '../../utils/display/blueprints-formatting.js';
 import { styleText } from '../../utils/style-text.js';
@@ -9,6 +10,7 @@ export async function blueprintPlanCore(options) {
     const { verbose: _verbose = false } = flags;
     const { scopeType, scopeId, stackId: blueprintStackId, parsedBlueprint, resources, fileInfo, } = blueprint;
     log(`${styleText(['bold', 'blueBright'], 'Local Blueprint')} ${styleText('dim', `(${fileInfo.fileName})`)}`);
+    await extractDurableConfig(resources, dirname(fileInfo.blueprintFilePath));
     log(formatResourceTree(resources));
     if (!token || !scopeType || !scopeId) {
         log(styleText('dim', 'Unable to retrieve live Stack deployment for comparison'));

package/dist/cores/functions/add.js

@@ -5,7 +5,7 @@ import { checkbox, confirm, input, select } from '@inquirer/prompts';
 import { highlight } from 'cardinal';
 import { createFunctionResource } from '../../actions/blueprints/resources.js';
 import { verifyExampleExists, writeExample } from '../../actions/sanity/examples.js';
-import { EVENT_DOCUMENT_CREATE, EVENT_DOCUMENT_DELETE, EVENT_DOCUMENT_UPDATE, EVENT_MEDIA_LIBRARY_ASSET_CREATE, EVENT_MEDIA_LIBRARY_ASSET_DELETE, EVENT_MEDIA_LIBRARY_ASSET_UPDATE, EVENT_SCHEDULED, EVENT_SYNC_TAG_INVALIDATE, FUNCTION_TYPES, LABEL_DOCUMENT_CREATE, LABEL_DOCUMENT_DELETE, LABEL_DOCUMENT_UPDATE, LABEL_MEDIA_LIBRARY_ASSET_CREATE, LABEL_MEDIA_LIBRARY_ASSET_DELETE, LABEL_MEDIA_LIBRARY_ASSET_UPDATE, LABEL_SCHEDULED, LABEL_SYNC_TAG_INVALIDATE, MAP_EVENT_TO_FUNCTION_TYPE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../constants.js';
+import { EVENT_DOCUMENT_CREATE, EVENT_DOCUMENT_DELETE, EVENT_DOCUMENT_UPDATE, EVENT_MEDIA_LIBRARY_ASSET_CREATE, EVENT_MEDIA_LIBRARY_ASSET_DELETE, EVENT_MEDIA_LIBRARY_ASSET_UPDATE, EVENT_PUBSUB, EVENT_SCHEDULED, EVENT_SYNC_TAG_INVALIDATE, FUNCTION_TYPES, LABEL_DOCUMENT_CREATE, LABEL_DOCUMENT_DELETE, LABEL_DOCUMENT_UPDATE, LABEL_MEDIA_LIBRARY_ASSET_CREATE, LABEL_MEDIA_LIBRARY_ASSET_DELETE, LABEL_MEDIA_LIBRARY_ASSET_UPDATE, LABEL_PUBSUB, LABEL_SCHEDULED, LABEL_SYNC_TAG_INVALIDATE, MAP_EVENT_TO_FUNCTION_TYPE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, } from '../../constants.js';
 import { check, indent, warn } from '../../utils/display/presenters.js';
 import { validateFunctionName } from '../../utils/functions/validate-name.js';
 import { styleText } from '../../utils/style-text.js';
@@ -21,6 +21,9 @@ export const generateFunctionBlueprintResourceTemplate = (fnName, eventNames) =>
         case SANITY_FUNCTION_MEDIA_LIBRARY_ASSET:
             definer = `defineMediaLibraryAssetFunction({name: '${fnName}', event: {on: [${eventOns.join(', ')}], resource: {type: 'media-library', id: 'my-media-library-id'}}}), // ← add this line`;
             break;
+        case SANITY_FUNCTION_PUBSUB:
+            definer = `definePubSubFunction({name: '${fnName}'}), // ← add this line`;
+            break;
         case SANITY_FUNCTION_SCHEDULED:
             definer = `defineScheduledFunction({name: '${fnName}', event: {expression: '0 0 * * *'}}), // ← add this line`;
             break;
@@ -158,7 +161,7 @@ export async function functionAddCore(options) {
         }
         const eventSources = new Set(fnTypes.map((t) => t.substring(0, t.lastIndexOf('-'))));
         if (eventSources.size > 1) {
-            throw new Error('Invalid function type. Cannot mix document-*, media-library-asset-*, sync-tag-* and/or scheduled-* types.');
+            throw new Error('Invalid function type. Cannot mix document-*, media-library-asset-*, pub-sub, sync-tag-* and/or scheduled-* types.');
         }
         let addHelpers;
         let installCommand;
@@ -224,7 +227,7 @@ async function promptForFunctionName() {
     const functionName = await input({
         message: 'Enter function name:',
         validate: (input) => validateFunctionName(input) ||
-            'Invalid function name. Must be 6+ characters, no special characters, no spaces',
+            'Invalid function name. Must be 3+ characters, no special characters, no spaces',
     });
     return functionName;
 }
@@ -242,6 +245,7 @@ async function promptForFunctionType() {
             { name: LABEL_MEDIA_LIBRARY_ASSET_CREATE, value: EVENT_MEDIA_LIBRARY_ASSET_CREATE },
             { name: LABEL_MEDIA_LIBRARY_ASSET_UPDATE, value: EVENT_MEDIA_LIBRARY_ASSET_UPDATE },
             { name: LABEL_MEDIA_LIBRARY_ASSET_DELETE, value: EVENT_MEDIA_LIBRARY_ASSET_DELETE },
+            { name: LABEL_PUBSUB, value: EVENT_PUBSUB },
             { name: LABEL_SCHEDULED, value: EVENT_SCHEDULED },
             { name: LABEL_SYNC_TAG_INVALIDATE, value: EVENT_SYNC_TAG_INVALIDATE },
         ],
@@ -249,11 +253,10 @@ async function promptForFunctionType() {
             if (choices.length === 0) {
                 return 'You must choose at least one function type / document change event';
             }
-            const hasMedia = choices.some((c) => String(c.value).startsWith('media-library'));
-            const hasDocument = choices.some((c) => String(c.value).startsWith('document'));
-            const hasSchedule = choices.some((c) => String(c.value).startsWith('scheduled'));
-            if ((hasMedia && hasDocument) || (hasMedia && hasSchedule) || (hasDocument && hasSchedule)) {
-                return 'You cannot mix Document, Media Library Asset, and Scheduled events together in one Function';
+            // same grouping as the check in functionAddCore, so the prompt cannot drift from it
+            const eventSources = new Set(choices.map((c) => String(c.value).substring(0, String(c.value).lastIndexOf('-'))));
+            if (eventSources.size > 1) {
+                return 'You cannot mix Document, Media Library Asset, PubSub, Scheduled, and Sync Tag Invalidate events together in one Function';
             }
             return true;
         },

package/dist/server/static/components/api-base.js

@@ -9,6 +9,7 @@ export class ApiBaseElement extends HTMLElement {
     this.api = api
     this.SANITY_FUNCTION_DOCUMENT = 'sanity.function.document'
     this.SANITY_FUNCTION_MEDIA_LIBRARY_ASSET = 'sanity.function.media-library.asset'
+    this.SANITY_FUNCTION_PUBSUB = 'sanity.function.pubsub'
     this.SANITY_FUNCTION_SCHEDULED = 'sanity.function.cron'
     this.SANITY_FUNCTION_SYNC_TAG_INVALIDATE = 'sanity.function.sync-tag-invalidate'
   }

package/dist/server/static/components/filters.js

@@ -79,6 +79,7 @@ class FiltersComponent extends ApiBaseElement {
     const mediaFunction = this.api.store.selectedFunctionType?.startsWith(
       this.SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
     )
+    const pubsubFunction = this.api.store.selectedFunctionType === this.SANITY_FUNCTION_PUBSUB
     const scheduleFunction = this.api.store.selectedFunctionType === this.SANITY_FUNCTION_SCHEDULED
     const stiFunction =
       this.api.store.selectedFunctionType === this.SANITY_FUNCTION_SYNC_TAG_INVALIDATE
@@ -89,15 +90,16 @@ class FiltersComponent extends ApiBaseElement {
       mediaFunction,
       scheduleFunction,
       stiFunction,
+      pubsubFunction,
     )
   }
 
-  buildFilters = (docFunction, mediaFunction, scheduleFunction, stiFunction) => {
+  buildFilters = (docFunction, mediaFunction, scheduleFunction, stiFunction, pubsubFunction) => {
     return `
     <legend class="config-label">Client Options</legend>
     <div id="dynamic-dropdowns" class="flex gap-2">
       ${
-        docFunction || scheduleFunction || stiFunction
+        docFunction || scheduleFunction || stiFunction || pubsubFunction
           ? `<select-dropdown
         label="Project"
         store-key="projects"

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

@@ -164,6 +164,9 @@ class PayloadPanel extends ApiBaseElement {
     const payloadTitle = this.shadowRoot.querySelector('#payloadTitle')
     let title = 'Document'
     switch (selectedFunctionType) {
+      case this.SANITY_FUNCTION_PUBSUB:
+        title = 'PubSub Payload'
+        break
       case this.SANITY_FUNCTION_SYNC_TAG_INVALIDATE:
         title = 'Sync Tag Payload'
         break

package/dist/utils/blueprints/extract-durable-config.d.ts

@@ -0,0 +1,8 @@
+import { type BlueprintResource } from '@sanity/blueprints';
+/**
+ * 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.
+ * @param resources
+ * @param blueprintFileDir
+ */
+export declare const extractDurableConfig: (resources: BlueprintResource[], blueprintFileDir: string) => Promise<void>;

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

@@ -0,0 +1,60 @@
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { validateDurableFunction, } from '@sanity/blueprints';
+import { SANITY_FUNCTION_DURABLE } from '../../constants.js';
+import { findFunctionEntryPoint } from '../functions/find-entry-point.js';
+import { transpileFunction } from '../functions/transpile/function.js';
+import { isLocalFunctionResource } from '../types.js';
+const DURABLE_CONFIG_KEYS = ['event', 'concurrency', 'debounce', 'debounceKey'];
+/**
+ * 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.
+ * @param resources
+ * @param blueprintFileDir
+ */
+export const extractDurableConfig = async (resources, blueprintFileDir) => {
+    for (const resource of resources) {
+        if (!isLocalFunctionResource(resource))
+            continue;
+        // skip if not a durable function
+        if (resource.type !== SANITY_FUNCTION_DURABLE)
+            continue;
+        // Check if source needs to be transpiled before attempting to get config
+        const resourceSrc = resolve(blueprintFileDir, resource.src);
+        const entryPoint = await findFunctionEntryPoint(resourceSrc, resource.name);
+        let importPath = entryPoint;
+        let cleanup = async () => { };
+        // need to transpile and grab the config from the built output if the entry point is a TypeScript file
+        if (entryPoint.endsWith('.ts')) {
+            const built = await transpileFunction({ resource, functionPath: resourceSrc, entryPoint });
+            importPath = await findFunctionEntryPoint(built.outputDir, resource.name);
+            cleanup = built.cleanup;
+        }
+        let config = {};
+        try {
+            const mod = await import(pathToFileURL(importPath).href);
+            config = (mod.handler || mod.default)?.config;
+        }
+        finally {
+            await cleanup();
+        }
+        // Update values not included in the blueprint.
+        if (resource.event === undefined && config?.event !== undefined) {
+            resource.event = config.event;
+        }
+        if (resource.concurrency === undefined && config?.concurrency !== undefined) {
+            resource.concurrency = config.concurrency;
+        }
+        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) {
+            throw new Error(`Invalid durable resource "${resource.name}": ${errors.map((error) => error.message).join('; ')}`);
+        }
+    }
+};

package/dist/utils/blueprints/validate-resources.js

@@ -1,5 +1,5 @@
-import { validateCorsOrigin, validateDataset, validateDocumentFunction, validateDocumentWebhook, validateMediaLibraryAssetFunction, validateProject, validateRole, validateScheduledFunction, } from '@sanity/blueprints';
-import { SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
+import { validateCorsOrigin, validateDataset, validateDocumentFunction, validateDocumentWebhook, validateDurableFunction, validateMediaLibraryAssetFunction, validateProject, validateRole, validateScheduledFunction, } from '@sanity/blueprints';
+import { SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
 const RESOURCE_VALIDATORS = {
     [SANITY_ACCESS_ROLE]: {
         validate: validateRole,
@@ -25,6 +25,9 @@ const RESOURCE_VALIDATORS = {
     [SANITY_PROJECT_WEBHOOK]: {
         validate: validateDocumentWebhook,
     },
+    [SANITY_FUNCTION_DURABLE]: {
+        validate: validateDurableFunction,
+    },
 };
 export function validateResources(resources) {
     const errors = [];

package/dist/utils/display/blueprints-formatting.js

@@ -1,5 +1,5 @@
 import { treeify } from 'array-treeify';
-import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
+import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
 import { styleText } from '../style-text.js';
 import { isCorsOriginResource, isDatasetResource, isRobotResource, isRoleResource, isWebhookResource, } from '../types.js';
 import { formatDateTime, formatDuration } from './dates.js';
@@ -27,8 +27,10 @@ const RESOURCE_CATEGORIES = {
     },
     [SANITY_FUNCTION_DOCUMENT]: functionCategory,
     [SANITY_FUNCTION_MEDIA_LIBRARY_ASSET]: functionCategory,
+    [SANITY_FUNCTION_PUBSUB]: functionCategory,
     [SANITY_FUNCTION_SCHEDULED]: functionCategory,
     [SANITY_FUNCTION_SYNC_TAG_INVALIDATE]: functionCategory,
+    [SANITY_FUNCTION_DURABLE]: functionCategory,
     [SANITY_PROJECT]: {
         label: 'Projects',
         displayNameAttribute: 'displayName',
@@ -72,15 +74,15 @@ function resourceName(res, displayNameAttribute) {
         nameParts.push(styleText('green', `"${displayName}"`));
     return nameParts.join(' ');
 }
-function deployedResourceName(res, displayNameAttribute, _verbose = false) {
+function deployedResourceName(res, displayNameAttribute, verbose = false) {
     const nameParts = [styleText(['bold', 'green'], res.name)];
     const displayName = displayNameAttribute &&
         typeof res.parameters[displayNameAttribute] === 'string' &&
         res.parameters[displayNameAttribute];
     if (displayName && displayName !== res.name)
         nameParts.push(styleText('green', `"${displayName}"`));
-    // if (verbose)
-    nameParts.push(idList(res));
+    if (verbose)
+        nameParts.push(idList(res));
     return nameParts.join(' ');
 }
 function idList(res) {
@@ -215,11 +217,13 @@ export function formatStacksListing(stacks, currentStackId) {
 const IGNORED_PARAMS = {
     [SANITY_FUNCTION_DOCUMENT]: new Set(['src']),
     [SANITY_FUNCTION_MEDIA_LIBRARY_ASSET]: new Set(['src']),
+    [SANITY_FUNCTION_PUBSUB]: new Set(['src']),
     [SANITY_FUNCTION_SCHEDULED]: new Set(['src']),
 };
 const ASSET_RESOURCE_TYPES = new Set([
     SANITY_FUNCTION_DOCUMENT,
     SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
+    SANITY_FUNCTION_PUBSUB,
     SANITY_FUNCTION_SCHEDULED,
 ]);
 function stringifyUnknown(val) {

package/dist/utils/display/resources-formatting.js

@@ -1,4 +1,4 @@
-import { isLocalFunctionResource, isScheduleEvent } from '../../utils/types.js';
+import { hasEventSource, isLocalFunctionResource, isScheduleEvent, } from '../../utils/types.js';
 import { styleText } from '../style-text.js';
 function formatLabel(label) {
     return styleText('dim', `${label}:`);
@@ -46,7 +46,7 @@ export function arrayifyFunction(fn) {
         details.push(formatLabeledValue('memory', fn.memory));
     if (fn.timeout)
         details.push(formatLabeledValue('timeout', fn.timeout));
-    if (fn.event) {
+    if (hasEventSource(fn) && fn.event) {
         const eventDetails = arrayifyEvent(fn.event);
         if (eventDetails) {
             details.push(formatLabel('event'));

package/dist/utils/style-text.js

@@ -1,3 +1,4 @@
+// TODO: move to ./display
 import { env } from 'node:process';
 import { styleText as nodeStyleText } from 'node:util';
 import { isInteractive } from './interactive.js';