@sanity/runtime-cli 12.0.1 → 12.2.0

package/dist/cores/blueprints/config.js

@@ -1,15 +1,13 @@
-import { highlight } from 'cardinal';
 import chalk from 'chalk';
 import { patchConfigFile, writeConfigFile, } from '../../actions/blueprints/config.js';
-import { BLUEPRINT_CONFIG_DIR, BLUEPRINT_CONFIG_FILE } from '../../config.js';
-import { capitalize, filePathRelativeToCwd, niceId, warn } from '../../utils/display/presenters.js';
+import { filePathRelativeToCwd, labeledId, warn } from '../../utils/display/presenters.js';
 import { promptForProject, promptForStack } from '../../utils/display/prompt.js';
 export async function blueprintConfigCore(options) {
     const { bin = 'sanity', blueprint, log, token, flags } = options;
     const { edit: editConfig = false, 'project-id': flagProjectId, 'organization-id': flagOrganizationId, 'stack-id': flagStackId, verbose: v = false, } = flags;
+    const providedConfigFlag = [flagProjectId, flagStackId, flagOrganizationId].some(Boolean);
     const { stackId: configStackId, scopeType: configScopeType, scopeId: configScopeId, blueprintConfig, fileInfo, } = blueprint;
     const blueprintFilePath = fileInfo.blueprintFilePath;
-    const configPath = blueprintConfig?.configPath;
     if (!configStackId && !configScopeType && !configScopeId) {
         log(warn('Incomplete configuration.'));
         if (!editConfig) {
@@ -18,19 +16,10 @@ export async function blueprintConfigCore(options) {
             return { success: true }; // not necessarily fatal
         }
     }
-    log(chalk.bold('Current Blueprint configuration:'));
-    if (configPath) {
-        if (v)
-            log(`        File: ${filePathRelativeToCwd(configPath)}`);
-    }
-    log(`  Deployment: ${chalk.blue('Stack')} ${niceId(configStackId || 'unknown')}`);
-    log(`   Scoped to: ${chalk.blue(capitalize(configScopeType || 'unknown'))} ${niceId(configScopeId || 'unknown')}`);
-    if (blueprintConfig?.updatedAt) {
-        if (v)
-            log(`     Updated: ${new Date(blueprintConfig.updatedAt).toLocaleString()}`);
-    }
+    if (blueprintConfig)
+        printConfig({ configLabel: 'Current', log, config: blueprintConfig, v });
     // passing new config without --edit flag is not allowed
-    if ((flagProjectId || flagOrganizationId || flagStackId) && !editConfig) {
+    if (providedConfigFlag && !editConfig) {
         log('To update the configuration, use the --edit flag.');
         return { success: true };
     }
@@ -39,10 +28,9 @@ export async function blueprintConfigCore(options) {
         return { success: true };
     }
     else {
-        // if a config property flag was passed, set the value and return success
-        // do not try to validate correctness of combined flags; this should not be interactive
-        const providedConfigFlag = [flagProjectId, flagStackId, flagOrganizationId].some(Boolean);
         if (providedConfigFlag) {
+            // if a config property flag was passed, set the value and return success
+            // do not try to validate correctness of combined flags; this should not be interactive
             const configUpdate = {};
             if (flagProjectId)
                 configUpdate.projectId = flagProjectId;
@@ -51,19 +39,16 @@ export async function blueprintConfigCore(options) {
             if (flagOrganizationId)
                 configUpdate.organizationId = flagOrganizationId;
             try {
-                patchConfigFile(blueprintFilePath, configUpdate);
+                const newConfig = patchConfigFile(blueprintFilePath, configUpdate);
+                printConfig({ configLabel: 'Updated', log, config: newConfig, v });
+                return { success: true };
             }
             catch {
                 return { success: false, error: 'Unable to update configuration.' };
             }
-            log('\nConfiguration updated.');
-            return { success: true };
-        }
-        // organization-based Blueprints are not yet supported for interactive editing
-        if (configScopeType === 'organization') {
-            return { success: false, error: 'Only project-based Blueprints are supported.' };
         }
-        // otherwise, prompt for values interactively
+        // prompt for values interactively
+        // do not yet offer organization as scope option
         let updatedProjectId = flagProjectId;
         if (!updatedProjectId) {
             const pickedProject = await promptForProject({
@@ -83,21 +68,33 @@ export async function blueprintConfigCore(options) {
             return { success: false, error: 'Stack is required.' };
         try {
             // update or create config JSON
-            writeConfigFile({ blueprintFilePath, projectId: updatedProjectId, stackId: updatedStackId });
-            log(`\n${chalk.bold('New configuration:')}`);
-            log(`  Deployment: ${chalk.blue('Stack')} ${niceId(updatedStackId)}`);
-            log(`   Scoped to: ${chalk.blue('Project')} ${niceId(updatedProjectId)}`);
-            log('');
-            log('Configuration updated.');
+            const newConfig = await writeConfigFile(blueprintFilePath, {
+                projectId: updatedProjectId,
+                stackId: updatedStackId,
+            });
+            printConfig({ configLabel: 'Updated', log, config: newConfig, v });
             return { success: true };
         }
         catch {
-            log(`Unable to update config. These values should be set in ${BLUEPRINT_CONFIG_DIR}/${BLUEPRINT_CONFIG_FILE}`);
-            log(highlight(JSON.stringify({ metadata: { projectId: updatedProjectId, stackId: updatedStackId } }, null, 2)));
-            return {
-                success: false,
-                error: `Be sure to update your ${BLUEPRINT_CONFIG_DIR}/${BLUEPRINT_CONFIG_FILE}`,
-            };
+            return { success: false, error: 'Unable to update configuration!' };
         }
     }
 }
+function printConfig(options) {
+    const { configLabel, log, config, v = false } = options;
+    const { projectId, organizationId, stackId, updatedAt } = config;
+    const scopeType = projectId ? 'project' : 'organization';
+    const scopeId = projectId ? projectId : organizationId;
+    if (v)
+        log(JSON.stringify(config));
+    log(`${chalk.bold(`${configLabel} configuration:`)}`);
+    log(`  Deployment: ${labeledId('stack', stackId)}`);
+    log(`   Scoped to: ${labeledId(scopeType, scopeId)}`);
+    if (updatedAt)
+        log(`     Updated: ${new Date(updatedAt).toLocaleString()}`);
+    if ('configPath' in config) {
+        const { configPath } = config;
+        if (configPath)
+            log(`        File: ${filePathRelativeToCwd(configPath)}`);
+    }
+}

package/dist/cores/blueprints/doctor.d.ts

@@ -4,6 +4,7 @@ export interface BlueprintDoctorOptions extends CoreConfig {
     flags: {
         verbose?: boolean;
         path?: string;
+        fix?: boolean;
     };
 }
 export declare function blueprintDoctorCore(options: BlueprintDoctorOptions): Promise<CoreResult>;

package/dist/cores/blueprints/doctor.js

@@ -5,6 +5,7 @@ import { getStack } from '../../actions/blueprints/stacks.js';
 import config from '../../config.js';
 import { capitalize, check, filePathRelativeToCwd, indent, niceId, severe, unsure, } from '../../utils/display/presenters.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
+import { blueprintConfigCore } from './config.js';
 const diagLookup = {
     online: 'Online',
     tokenPresent: 'Auth token present',
@@ -17,12 +18,13 @@ const diagLookup = {
     userHasAccess: 'User has access to deployed "Stack"',
 };
 export async function blueprintDoctorCore(options) {
-    const { log, token, flags: { verbose: v, path: p }, } = options;
+    const { bin, log, token, flags: { verbose: v, path: p, fix }, } = options;
     const yikes = (s) => {
         log(chalk.bgRedBright.whiteBright.bold(` ${s} `));
     };
     const here = cwd();
     const path = p || here;
+    let tokenOrError;
     if (v)
         log(`Checking ${filePathRelativeToCwd(path)}`);
     // 3 states: null == unknown, true == good, false == bad
@@ -49,7 +51,7 @@ export async function blueprintDoctorCore(options) {
     // TOKEN
     if (token) {
         diagnostics.tokenPresent = true;
-        const tokenOrError = await validTokenOrErrorMessage(token);
+        tokenOrError = await validTokenOrErrorMessage(token);
         if (tokenOrError.ok) {
             diagnostics.tokenValid = true;
         }
@@ -91,7 +93,8 @@ export async function blueprintDoctorCore(options) {
         diagnostics.blueprintValid = false;
     }
     if (blueprint) {
-        const { configPath, scopeType, scopeId, stackId, projectId } = blueprint;
+        const { blueprintConfig, scopeType, scopeId, stackId, projectId } = blueprint;
+        const configPath = blueprintConfig?.configPath;
         // CONFIG file
         if (configPath) {
             if (v)
@@ -169,11 +172,39 @@ export async function blueprintDoctorCore(options) {
                 log(severe(`${key} is ${value}`));
         }
     }
+    const errorMessage = 'One or more checks failed';
     if (allGood) {
         log(chalk.bold.green('All checks passed'));
+        if (fix)
+            log(chalk.bold.yellow('Nothing to fix; --fix flag is ignored'));
         return { success: true, data: { diagnostics } };
     }
-    else {
-        return { success: false, error: 'One or more checks failed', data: { diagnostics } };
+    else if (fix) {
+        if (p) {
+            return { success: false, error: `${errorMessage}. --fix cannot be used with --path` };
+        }
+        if (!tokenOrError) {
+            return { success: false, error: `${errorMessage}. Unable to fix: Missing authentication token` };
+        }
+        if (tokenOrError?.ok === false) {
+            return {
+                success: false,
+                error: `${errorMessage}. Unable to fix: ${tokenOrError.error.message}`,
+            };
+        }
+        if (!blueprint) {
+            return {
+                success: false,
+                error: `${errorMessage}. Unable to fix: Blueprint is missing or invalid`,
+            };
+        }
+        return blueprintConfigCore({
+            bin,
+            log,
+            token: tokenOrError.value,
+            blueprint,
+            flags: { edit: true, verbose: v },
+        });
     }
+    return { success: false, error: errorMessage, data: { diagnostics } };
 }

package/dist/cores/blueprints/info.js

@@ -1,5 +1,5 @@
 import { getStack } from '../../actions/blueprints/stacks.js';
-import { formatResourceTree, formatStackInfo } from '../../utils/display/blueprints-formatting.js';
+import { formatDeployedResourceTree, formatStackInfo, } from '../../utils/display/blueprints-formatting.js';
 import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintInfoCore(options) {
     const { log, auth, stackId, flags, deployedStack } = options;
@@ -20,7 +20,7 @@ export async function blueprintInfoCore(options) {
         }
         log(formatStackInfo(stack, true));
         if (stack.resources)
-            log(formatResourceTree(stack.resources));
+            log(formatDeployedResourceTree(stack.resources));
         return { success: true };
     }
     catch (error) {

package/dist/cores/blueprints/init.d.ts

@@ -33,11 +33,13 @@ export declare function resolveScopeAndStack(params: {
     organizationId: string | undefined;
     stackId: string | undefined;
     stackName: string | undefined;
+    log: (message: string) => void;
     token: string;
 }): Promise<ResolvedScope>;
 export declare function determineBlueprintExtension(params: {
     requestedType: string | undefined;
     blueprintDir: string;
+    log: (message: string) => void;
 }): Promise<string>;
 export declare function createBlueprintFiles(params: {
     blueprintDir: string;

package/dist/cores/blueprints/init.js

@@ -9,7 +9,7 @@ import { writeGitignoreFile } from '../../actions/git.js';
 import { writeOrUpdateNodeDependency } from '../../actions/node.js';
 import { verifyExampleExists, writeExample } from '../../actions/sanity/examples.js';
 import { BLUEPRINT_CONFIG_DIR, BLUEPRINT_CONFIG_FILE } from '../../config.js';
-import { check, filePathRelativeToCwd, warn } from '../../utils/display/presenters.js';
+import { check, filePathRelativeToCwd, labeledId, warn } from '../../utils/display/presenters.js';
 import { promptForBlueprintType, promptForProject, promptForStack, } from '../../utils/display/prompt.js';
 import { blueprintConfigCore } from './config.js';
 const SCOPE_PROJECT = 'project';
@@ -20,6 +20,7 @@ export async function blueprintInitCore(options) {
     const { dir: argDir } = args;
     const userProvidedDirName = argDir || flagDir;
     const blueprintDir = userProvidedDirName || '.';
+    const flagProvidedConfig = [flagProjectId, flagOrganizationId, flagStackId].some(Boolean);
     const validationError = validateFlags({
         stackId: flagStackId,
         stackName: flagStackName,
@@ -29,15 +30,30 @@ export async function blueprintInitCore(options) {
     if (validationError)
         return validationError;
     try {
+        // look for existing blueprint file and maybe re-configure it
         const existingBlueprintFile = findBlueprintFile(blueprintDir);
         if (existingBlueprintFile) {
             log(warn(`Existing Blueprint found: ${filePathRelativeToCwd(existingBlueprintFile.blueprintFilePath)}`));
-            const overwrite = await confirm({
-                message: 'Would you like to re-configure deployment for this Blueprint?',
-                default: true,
-            });
-            if (!overwrite)
-                return { success: false, error: 'Initialization cancelled.' };
+            if (flagExample) {
+                return {
+                    success: false,
+                    error: 'Flag --example cannot be used with an existing Blueprint.',
+                };
+            }
+            if (flagStackName) {
+                return {
+                    success: false,
+                    error: 'Flag --stack-name cannot be used with an existing Blueprint.',
+                };
+            }
+            if (!flagProvidedConfig) {
+                const overwrite = await confirm({
+                    message: 'Would you like to re-configure deployment for this Blueprint?',
+                    default: true,
+                });
+                if (!overwrite)
+                    return { success: false, error: 'Initialization cancelled.' };
+            }
             const existingBlueprint = await readLocalBlueprint(existingBlueprintFile.blueprintFilePath);
             return blueprintConfigCore({
                 blueprint: existingBlueprint,
@@ -68,11 +84,13 @@ export async function blueprintInitCore(options) {
             organizationId: flagOrganizationId,
             stackId: flagStackId,
             stackName: flagStackName,
+            log,
             token,
         });
         const blueprintExtension = await determineBlueprintExtension({
             requestedType: flagBlueprintType,
             blueprintDir,
+            log,
         });
         return createBlueprintFiles({
             blueprintDir,
@@ -87,7 +105,6 @@ export async function blueprintInitCore(options) {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        log(`Error: ${errorMessage}`);
         return { success: false, error: errorMessage };
     }
 }
@@ -136,7 +153,7 @@ async function handleExampleInitialization(options) {
         return { success: false, error: 'Failed to find blueprint file.' };
     }
     const { blueprintFilePath } = discoveredBlueprint;
-    writeConfigFile({ blueprintFilePath, projectId: resolvedProjectId, stackId: stack.id });
+    writeConfigFile(blueprintFilePath, { projectId: resolvedProjectId, stackId: stack.id });
     log(check(`${chalk.bold('Configured:')} ${exampleDir}/${BLUEPRINT_CONFIG_DIR}/${BLUEPRINT_CONFIG_FILE}`));
     log(`\n  Run "${chalk.bold.magenta(`cd ${exampleDir} && npm i`)}" and check out the README`);
     if (instructions) {
@@ -146,7 +163,7 @@ async function handleExampleInitialization(options) {
     return { success: true };
 }
 export async function resolveScopeAndStack(params) {
-    const { projectId, organizationId, stackId, stackName, token } = params;
+    const { projectId, organizationId, stackId, stackName, log, token } = params;
     let scopeType = SCOPE_PROJECT;
     let scopeId;
     if (projectId) {
@@ -159,7 +176,9 @@ export async function resolveScopeAndStack(params) {
     }
     let resolvedStackId = stackId;
     if (!resolvedStackId && stackName && scopeType && scopeId) {
+        // sending stackName will assume you want to create a new stack
         // essentially the only way to create an org-scoped stack
+        log(`\nCreating new Stack "${stackName}" scoped to ${labeledId(scopeType, scopeId)}`);
         const stack = await createEmptyStack({
             token,
             scopeType,
@@ -169,11 +188,13 @@ export async function resolveScopeAndStack(params) {
         resolvedStackId = stack.id;
     }
     if (!scopeId) {
+        log('\nBlueprints are associated with a Sanity Project. Please select one:');
         const pickedProject = await promptForProject({ token });
         scopeType = SCOPE_PROJECT;
         scopeId = pickedProject.projectId;
     }
     if (!resolvedStackId) {
+        log('\nBlueprints are deployed to a "Stack".');
         const { stackId } = await promptForStack({ projectId: scopeId, token });
         resolvedStackId = stackId;
     }
@@ -184,11 +205,14 @@ export async function resolveScopeAndStack(params) {
     };
 }
 export async function determineBlueprintExtension(params) {
-    const { requestedType, blueprintDir } = params;
+    const { requestedType, blueprintDir, log } = params;
     let extension = requestedType;
-    if (!extension)
+    if (!extension) {
+        log('\nBlueprint files are authored locally to create resources in your Stack.');
         extension = await promptForBlueprintType();
+    }
     if (extension === 'js') {
+        // do we need to use .mjs or .js?
         const packageJsonPath = join(blueprintDir, 'package.json');
         const packageExists = existsSync(packageJsonPath);
         if (packageExists) {
@@ -209,6 +233,7 @@ export async function createBlueprintFiles(params) {
     if (!blueprintExtension) {
         return { success: false, error: 'Blueprint type is required.' };
     }
+    log(`\nCreating local Blueprint setup...`);
     const blueprintFileName = `sanity.blueprint.${blueprintExtension}`;
     const blueprintFilePath = join(blueprintDir, blueprintFileName);
     writeBlueprintToDisk({ blueprintFilePath });
@@ -217,8 +242,7 @@ export async function createBlueprintFiles(params) {
     }
     const displayPath = userProvidedDirName || '.';
     log(check(`${chalk.bold('Created Blueprint:')}   ${displayPath}/${blueprintFileName}`));
-    writeConfigFile({
-        blueprintFilePath,
+    writeConfigFile(blueprintFilePath, {
         stackId,
         ...(scopeType === SCOPE_ORGANIZATION ? { organizationId: scopeId } : { projectId: scopeId }),
     });

package/dist/cores/functions/env/add.js

@@ -1,11 +1,11 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { update } from '../../../actions/functions/env/update.js';
-import { findFunctionByName } from '../../../utils/find-function.js';
+import { findFunctionInStack } from '../../../utils/find-function.js';
 export async function functionEnvAddCore(options) {
     const args = options.args;
     const spinner = ora(`Updating "${args.key}" environment variable in "${args.name}"`).start();
-    const { externalId } = findFunctionByName(options.deployedStack, args.name);
+    const { externalId } = findFunctionInStack(options.deployedStack, args.name);
     const result = await update(externalId, args.key, args.value, options.auth);
     if (!result.ok) {
         spinner.fail(`${chalk.red('Failed')} to update ${args.key}`);

package/dist/cores/functions/env/list.js

@@ -1,10 +1,10 @@
 import ora from 'ora';
 import { list } from '../../../actions/functions/env/list.js';
-import { findFunctionByName } from '../../../utils/find-function.js';
+import { findFunctionInStack } from '../../../utils/find-function.js';
 export async function functionEnvListCore(options) {
     const args = options.args;
     const spinner = ora(`Listing environment variables for "${args.name}"`).start();
-    const { externalId } = findFunctionByName(options.deployedStack, args.name);
+    const { externalId } = findFunctionInStack(options.deployedStack, args.name);
     const result = await list(externalId, options.auth);
     if (!result.ok) {
         spinner.stop();

package/dist/cores/functions/env/remove.js

@@ -1,11 +1,11 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { remove } from '../../../actions/functions/env/remove.js';
-import { findFunctionByName } from '../../../utils/find-function.js';
+import { findFunctionInStack } from '../../../utils/find-function.js';
 export async function functionEnvRemoveCore(options) {
     const args = options.args;
     const spinner = ora(`Removing "${args.key}" environment variable in "${args.name}"`).start();
-    const { externalId } = findFunctionByName(options.deployedStack, args.name);
+    const { externalId } = findFunctionInStack(options.deployedStack, args.name);
     const result = await remove(externalId, args.key, options.auth);
     if (!result.ok) {
         spinner.fail(`${chalk.red('Failed')} to remove ${args.key}`);

package/dist/cores/functions/logs.js

@@ -4,12 +4,12 @@ import ora from 'ora';
 import { deleteLogs as deleteLogsAction, logs as getLogsAction, streamLogs as streamLogsAction, } from '../../actions/functions/logs.js';
 import { formatTitle } from '../../utils/display/blueprints-formatting.js';
 import { niceId } from '../../utils/display/presenters.js';
-import { findFunctionByName } from '../../utils/find-function.js';
+import { findFunctionInStack } from '../../utils/find-function.js';
 export async function functionLogsCore(options) {
     const { args, flags, log, auth, deployedStack } = options;
     const { name } = args;
     const { delete: shouldDelete, watch: shouldWatch, force, limit, json, utc } = flags;
-    const { externalId } = findFunctionByName(deployedStack, name); // throws if not found
+    const { externalId } = findFunctionInStack(deployedStack, name); // throws if not found
     if (shouldDelete)
         return deleteLogs({ name, externalId, auth, force, log });
     if (shouldWatch)

package/dist/cores/functions/test.js

@@ -4,11 +4,12 @@ import { cwd } from 'node:process';
 import ora from 'ora';
 import { testAction } from '../../actions/functions/test.js';
 import config from '../../config.js';
+import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET } from '../../constants.js';
 import buildPayload from '../../utils/build-payload.js';
-import { findFunctionByName } from '../../utils/find-function.js';
+import { findFunctionInBlueprint } from '../../utils/find-function.js';
 import { fetchAsset, fetchDocument } from '../../utils/functions/fetch-document.js';
 import { parseJsonObject } from '../../utils/parse-json-object.js';
-import { isEventType, } from '../../utils/types.js';
+import { isEventType, isGroqContextOptions, } from '../../utils/types.js';
 export async function functionTestCore(options) {
     const { blueprint, log, args, flags } = options;
     const { name: fnName } = args;
@@ -29,22 +30,25 @@ export async function functionTestCore(options) {
         };
     }
     try {
-        const resource = findFunctionByName(parsedBlueprint, fnName); // throws if not found
-        const docFunction = resource.type === 'sanity.function.document';
-        const contextOptions = {
-            clientOptions: {
-                apiVersion: api,
-                dataset,
-                projectId,
-                organizationId,
-            },
-            eventResourceType: docFunction ? 'dataset' : 'media-library',
-            eventResourceId: (docFunction ? `${projectId}.${dataset}` : mediaLibraryId) || '',
-            functionResourceType: 'project',
-            functionResourceId: (docFunction ? projectId : organizationId) || '',
-        };
+        const resource = findFunctionInBlueprint(parsedBlueprint, fnName); // throws if not found
+        const docFunction = resource.type === SANITY_FUNCTION_DOCUMENT;
+        const mediaFunction = resource.type === SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
+        const contextOptions = docFunction || mediaFunction
+            ? {
+                clientOptions: {
+                    apiVersion: api,
+                    dataset,
+                    projectId,
+                    organizationId,
+                },
+                eventResourceType: docFunction ? 'dataset' : 'media-library',
+                eventResourceId: (docFunction ? `${projectId}.${dataset}` : mediaLibraryId) || '',
+                functionResourceType: 'project',
+                functionResourceId: projectId || '',
+            }
+            : {};
         // If the user sets the flag to use the real token set it in our options
-        if (withUserToken) {
+        if (withUserToken && isGroqContextOptions(contextOptions)) {
             contextOptions.clientOptions.token = config.token || undefined;
         }
         let before = null;
@@ -115,12 +119,16 @@ export async function functionTestCore(options) {
                 payload = buildPayload({ data, file });
             }
         }
-        const invokeOptions = {
-            event: eventType,
-            payload,
-            before,
-            after,
-        };
+        const invokeOptions = docFunction || mediaFunction
+            ? {
+                event: eventType,
+                payload,
+                before,
+                after,
+            }
+            : {
+                event: 'schedule',
+            };
         const spinner = ora('Executing function...').start();
         const { json, logs, error } = await testAction(resource, invokeOptions, contextOptions, {
             timeout: timeout ? timeout : resource.timeout,

package/dist/server/app.js

@@ -5,7 +5,7 @@ import { WebSocketServer } from 'ws';
 import { readLocalBlueprint } from '../actions/blueprints/blueprint.js';
 import config from '../config.js';
 import { isRecord } from '../utils/is-record.js';
-import { isEventType, } from '../utils/types.js';
+import { isEventType, isGroqContextOptions, } from '../utils/types.js';
 import { handleInvokeRequest } from './handlers/invoke.js';
 const app = (host, port, executionOptions) => {
     const requestListener = async (req, res) => {
@@ -34,11 +34,13 @@ const app = (host, port, executionOptions) => {
                             const { data, func: functionName, metadata } = parseInvokeRequest(Buffer.concat(body));
                             const { context, event } = data;
                             // replace user token if required
-                            if (context.clientOptions.token) {
-                                context.clientOptions.token = config.token || undefined;
-                            }
-                            else {
-                                delete context.clientOptions.token;
+                            if (isGroqContextOptions(context)) {
+                                if (context.clientOptions.token) {
+                                    context.clientOptions.token = config.token || undefined;
+                                }
+                                else {
+                                    delete context.clientOptions.token;
+                                }
                             }
                             const result = await handleInvokeRequest(functionName, event, metadata, context, executionOptions);
                             // Add Server-Timing header
@@ -324,21 +326,30 @@ function parseInvokeRequest(body) {
         throw new Error('Request body is not valid, `metadata.event` field is missing');
     }
     const metadataEvent = metadata.event;
-    if (typeof metadataEvent !== 'string' || !isEventType(metadataEvent)) {
-        throw new Error('Request body is not valid, `metadata.event` field is not one of `create`, `update`, or `delete`');
-    }
-    if (!('before' in metadata)) {
-        throw new Error('Request body is not valid, `metadata.before` field is missing');
-    }
-    if (!('after' in metadata)) {
-        throw new Error('Request body is not valid, `metadata.after` field is missing');
-    }
-    const { before, after } = metadata;
-    if (!isRecord(before) && before !== null) {
-        throw new Error('Request body is not valid, `metadata.before` field is not an object');
+    if (typeof metadataEvent !== 'string' ||
+        (!isEventType(metadataEvent) && metadataEvent !== 'schedule')) {
+        throw new Error('Request body is not valid, `metadata.event` field is not one of `create`, `update`, `delete`, or `schedule`');
     }
-    if (!isRecord(after) && after !== null) {
-        throw new Error('Request body is not valid, `metadata.after` field is not an object');
+    let before = null;
+    let after = null;
+    // Only GROQ-based events (create, update, delete) have before and after fields
+    if (metadataEvent !== 'schedule') {
+        if (!('before' in metadata)) {
+            throw new Error('Request body is not valid, `metadata.before` field is missing');
+        }
+        if (!('after' in metadata)) {
+            throw new Error('Request body is not valid, `metadata.after` field is missing');
+        }
+        const beforeValue = metadata.before;
+        const afterValue = metadata.after;
+        if (!isRecord(beforeValue) && beforeValue !== null) {
+            throw new Error('Request body is not valid, `metadata.before` field is not an object');
+        }
+        if (!isRecord(afterValue) && afterValue !== null) {
+            throw new Error('Request body is not valid, `metadata.after` field is not an object');
+        }
+        before = beforeValue;
+        after = afterValue;
     }
     const clientOptions = {
         ...context.clientOptions,
@@ -361,7 +372,7 @@ function parseInvokeRequest(body) {
             },
             event,
         },
-        metadata: { event: metadataEvent, before, after },
+        metadata: metadataEvent === 'schedule' ? { event: metadataEvent } : { event: metadataEvent, before, after },
     };
 }
 export { app, buildApiUrl, parseDocumentUrl };

package/dist/server/handlers/invoke.d.ts

@@ -1,4 +1,4 @@
-import type { InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadOptions } from '../../utils/types.js';
-export declare function handleInvokeRequest(functionName: string, event: Record<string, unknown>, metadata: Pick<InvokePayloadOptions, 'event' | 'before' | 'after'>, context: InvokeContextOptions, executionOptions?: Partial<InvokeExecutionOptions>): Promise<InvocationResponse & {
+import type { InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadMetadata } from '../../utils/types.js';
+export declare function handleInvokeRequest(functionName: string, event: Record<string, unknown>, metadata: InvokePayloadMetadata, context: InvokeContextOptions, executionOptions?: Partial<InvokeExecutionOptions>): Promise<InvocationResponse & {
     timings: Record<string, number>;
 }>;

package/dist/server/handlers/invoke.js

@@ -1,10 +1,10 @@
 import { readLocalBlueprint } from '../../actions/blueprints/blueprint.js';
-import { findFunctionByName } from '../../utils/find-function.js';
+import { findFunctionInBlueprint } from '../../utils/find-function.js';
 import invoke from '../../utils/invoke-local.js';
 export async function handleInvokeRequest(functionName, event, metadata, context, executionOptions) {
     const start = performance.now();
     const { parsedBlueprint } = await readLocalBlueprint();
-    const resource = findFunctionByName(parsedBlueprint, functionName);
+    const resource = findFunctionInBlueprint(parsedBlueprint, functionName);
     const readBlueprintTime = performance.now() - start;
     const payload = {
         payload: event,

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

@@ -7,5 +7,8 @@ export class ApiBaseElement extends HTMLElement {
   constructor() {
     super()
     this.api = api
+    this.SANITY_FUNCTION_DOCUMENT = 'sanity.function.document'
+    this.SANITY_FUNCTION_MEDIA_LIBRARY_ASSET = 'sanity.function.media-library.asset'
+    this.SANITY_FUNCTION_SCHEDULE = 'sanity.function.cron'
   }
 }