@sanity/runtime-cli 4.5.1 → 5.0.1

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @sanity/runtime-cli
 $ sanity-run COMMAND
 running command...
 $ sanity-run (--version)
-@sanity/runtime-cli/4.5.1 linux-x64 node-v22.15.0
+@sanity/runtime-cli/5.0.1 linux-x64 node-v22.15.0
 $ sanity-run --help [COMMAND]
 USAGE
   $ sanity-run COMMAND
@@ -48,32 +48,37 @@ USAGE
 
 ## `sanity-run blueprints add TYPE`
 
-Add a resource to a Blueprint
+Add a (function) resource to a Blueprint
 
 ```
 USAGE
-  $ sanity-run blueprints add TYPE [--function-type document-publish -n <value>]
+  $ sanity-run blueprints add TYPE [--fn-type document-publish -n <value>] [--language ts|js] [--javascript]
 
 ARGUMENTS
   TYPE  (function) Type of resource to add (e.g. function)
 
 FLAGS
-  -n, --name=<value>            Name of the resource to add
-      --function-type=<option>  Type of function to add (e.g. document-publish)
-                                <options: document-publish>
+  -n, --name=<value>       Name of the resource to add
+      --fn-type=<option>   Type of new function
+                           <options: document-publish>
+      --javascript         Use JavaScript instead of TypeScript
+      --language=<option>  [default: ts] Language of the new function
+                           <options: ts|js>
 
 DESCRIPTION
-  Add a resource to a Blueprint
+  Add a (function) resource to a Blueprint
 
 EXAMPLES
   $ sanity-run blueprints add function
 
   $ sanity-run blueprints add function --name my-function
 
-  $ sanity-run blueprints add function --name my-function --function-type document-publish
+  $ sanity-run blueprints add function --name my-function --fn-type document-publish
+
+  $ sanity-run blueprints add function --name my-function --fn-type document-publish --lang js
 ```
 
-_See code: [src/commands/blueprints/add.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/blueprints/add.ts)_
+_See code: [src/commands/blueprints/add.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/blueprints/add.ts)_
 
 ## `sanity-run blueprints config`
 
@@ -101,7 +106,7 @@ EXAMPLES
   $ sanity-run blueprints config --edit --project-id <projectId>
 ```
 
-_See code: [src/commands/blueprints/config.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/blueprints/config.ts)_
+_See code: [src/commands/blueprints/config.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/blueprints/config.ts)_
 
 ## `sanity-run blueprints deploy`
 
@@ -123,11 +128,11 @@ EXAMPLES
   $ sanity-run blueprints deploy --no-wait
 ```
 
-_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/blueprints/deploy.ts)_
+_See code: [src/commands/blueprints/deploy.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/blueprints/deploy.ts)_
 
 ## `sanity-run blueprints destroy`
 
-Destroy a Blueprint deployment
+Destroy a Blueprint deployment (will not delete local files)
 
 ```
 USAGE
@@ -137,13 +142,13 @@ FLAGS
   --force  Force destroy (skip confirmation)
 
 DESCRIPTION
-  Destroy a Blueprint deployment
+  Destroy a Blueprint deployment (will not delete local files)
 
 EXAMPLES
   $ sanity-run blueprints destroy
 ```
 
-_See code: [src/commands/blueprints/destroy.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/blueprints/destroy.ts)_
+_See code: [src/commands/blueprints/destroy.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/blueprints/destroy.ts)_
 
 ## `sanity-run blueprints info`
 
@@ -160,7 +165,7 @@ EXAMPLES
   $ sanity-run blueprints info
 ```
 
-_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/blueprints/info.ts)_
+_See code: [src/commands/blueprints/info.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/blueprints/info.ts)_
 
 ## `sanity-run blueprints init [DIR]`
 
@@ -192,7 +197,7 @@ EXAMPLES
   $ sanity-run blueprints init --blueprint-type <json|js|ts> --project-id <projectId>
 ```
 
-_See code: [src/commands/blueprints/init.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/blueprints/init.ts)_
+_See code: [src/commands/blueprints/init.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/blueprints/init.ts)_
 
 ## `sanity-run blueprints logs`
 
@@ -214,7 +219,7 @@ EXAMPLES
   $ sanity-run blueprints logs --watch
 ```
 
-_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/blueprints/logs.ts)_
+_See code: [src/commands/blueprints/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/blueprints/logs.ts)_
 
 ## `sanity-run blueprints plan`
 
@@ -231,7 +236,7 @@ EXAMPLES
   $ sanity-run blueprints plan
 ```
 
-_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/blueprints/plan.ts)_
+_See code: [src/commands/blueprints/plan.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/blueprints/plan.ts)_
 
 ## `sanity-run functions dev`
 
@@ -251,7 +256,7 @@ EXAMPLES
   $ sanity-run functions dev --port 8974
 ```
 
-_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/functions/dev.ts)_
+_See code: [src/commands/functions/dev.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/functions/dev.ts)_
 
 ## `sanity-run functions env add NAME KEY VALUE`
 
@@ -273,7 +278,7 @@ EXAMPLES
   $ sanity-run functions env add MyFunction API_URL https://api.example.com/
 ```
 
-_See code: [src/commands/functions/env/add.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/functions/env/add.ts)_
+_See code: [src/commands/functions/env/add.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/functions/env/add.ts)_
 
 ## `sanity-run functions env list NAME`
 
@@ -293,7 +298,7 @@ EXAMPLES
   $ sanity-run functions env list MyFunction
 ```
 
-_See code: [src/commands/functions/env/list.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/functions/env/list.ts)_
+_See code: [src/commands/functions/env/list.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/functions/env/list.ts)_
 
 ## `sanity-run functions env remove NAME KEY`
 
@@ -314,7 +319,7 @@ EXAMPLES
   $ sanity-run functions env remove MyFunction API_URL
 ```
 
-_See code: [src/commands/functions/env/remove.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/functions/env/remove.ts)_
+_See code: [src/commands/functions/env/remove.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/functions/env/remove.ts)_
 
 ## `sanity-run functions invoke NAME`
 
@@ -340,7 +345,7 @@ EXAMPLES
   $ sanity-run functions invoke <name> --file 'payload.json'
 ```
 
-_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/functions/invoke.ts)_
+_See code: [src/commands/functions/invoke.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/functions/invoke.ts)_
 
 ## `sanity-run functions logs NAME`
 
@@ -372,7 +377,7 @@ EXAMPLES
   $ sanity-run functions logs <name> --delete
 ```
 
-_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/functions/logs.ts)_
+_See code: [src/commands/functions/logs.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/functions/logs.ts)_
 
 ## `sanity-run functions test NAME`
 
@@ -405,7 +410,7 @@ EXAMPLES
   $ sanity-run functions test <name> --data '{ "id": 1 }' --timeout 60
 ```
 
-_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v4.5.1/src/commands/functions/test.ts)_
+_See code: [src/commands/functions/test.ts](https://github.com/sanity-io/runtime-cli/blob/v5.0.1/src/commands/functions/test.ts)_
 
 ## `sanity-run help [COMMAND]`
 

package/dist/actions/blueprints/blueprint.js

@@ -3,6 +3,8 @@ import { createRequire } from 'node:module';
 import { basename, dirname, extname, join } from 'node:path';
 import { cwd } from 'node:process';
 import { findUpSync } from 'find-up';
+import { isLocalFunctionResource } from '../../utils/types.js';
+import { validateFunctionResource } from '../../utils/validate/resource.js';
 import { blueprintParserValidator } from '../../utils/vendor/parser-validator.js';
 const SUPPORTED_FILE_EXTENSIONS = ['.json', '.js', '.mjs', '.cjs', '.ts'];
 const SUPPORTED_FILE_NAMES_IN_PRIORITY_ORDER = SUPPORTED_FILE_EXTENSIONS.map((ext) => `blueprint${ext}`);
@@ -108,37 +110,23 @@ export async function readLocalBlueprint(blueprintPath) {
         }
     }
     const parserResult = blueprintParserValidator(rawBlueprint);
-    const { blueprint: parsedBlueprint } = parserResult;
+    const parsedBlueprint = parserResult.blueprint;
     const errors = parserResult.errors || [];
+    // further validation - remove once validator is updated
+    if (parsedBlueprint.resources) {
+        // validate function resources
+        const functionResources = parsedBlueprint.resources.filter(isLocalFunctionResource);
+        const fnErrors = functionResources.map((r) => validateFunctionResource(r));
+        errors.push(...fnErrors.flat());
+    }
     const configIds = readConfigFile(foundPath);
     const configPath = configIds?.configPath;
-    const blueprintMetadata = parsedBlueprint.metadata;
-    // find projectId
     let projectId;
-    if (configIds?.projectId) {
+    if (configIds?.projectId)
         projectId = configIds.projectId;
-    }
-    else if (blueprintMetadata?.projectId) {
-        projectId = blueprintMetadata.projectId;
-    }
-    else {
-        const projectResource = parsedBlueprint.resources.find((r) => r.type === 'sanity.project');
-        if (projectResource)
-            projectId = projectResource.id;
-    }
-    // find stackId
     let stackId;
-    if (configIds?.stackId) {
+    if (configIds?.stackId)
         stackId = configIds.stackId;
-    }
-    else if (blueprintMetadata?.stackId) {
-        stackId = blueprintMetadata.stackId;
-    }
-    else {
-        const stackResource = parsedBlueprint.resources.find((r) => r.type === 'sanity.blueprints.stack');
-        if (stackResource)
-            stackId = stackResource.id;
-    }
     // LAUNCH LIMIT: 1 Stack per Project - infer stackId from projectId
     if (!stackId && projectId)
         stackId = `ST-${projectId}`;

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

@@ -2,6 +2,7 @@ import type { LocalFunctionResource } from '../../utils/types.js';
 interface FunctionResourceOptions {
     name: string;
     type: string;
+    lang: string;
     displayName?: string;
     blueprintFilePath?: string;
 }

package/dist/actions/blueprints/resources.js

@@ -7,16 +7,16 @@ const DEFAULT_FUNCTION_TEMPLATE = /*js*/ `export async function handler({context
   const time = new Date().toLocaleTimeString()
   console.log(\`👋 Your Sanity Function was called at \${time}\`)
 }`;
-const DEFAULT_PACKAGE_JSON = `{
-  "name": "<<NAME>>",
-  "type": "module",
-  "main": "index.js"
-}`;
+const DEFAULT_PACKAGE_JSON = {
+    name: '',
+    type: 'module',
+    main: '',
+};
 /**
  * Creates a new function resource file and adds it to the blueprint
  */
 export function createFunctionResource(options) {
-    const { name, type, displayName = name, blueprintFilePath } = options;
+    const { name, type, lang, displayName = name, blueprintFilePath } = options;
     let workingDir = cwd();
     if (blueprintFilePath) {
         if (!existsSync(blueprintFilePath)) {
@@ -34,19 +34,32 @@ export function createFunctionResource(options) {
     if (!existsSync(functionDir)) {
         mkdirSync(functionDir, { recursive: true });
     }
-    // Create index.js with default template
-    const indexPath = join(functionDir, 'index.js');
+    if (!['ts', 'js'].includes(lang))
+        throw Error(`Unsupported language: ${lang}`);
+    // Create index.<lang> with default template
+    const indexPath = join(functionDir, `index.${lang}`);
     writeFileSync(indexPath, DEFAULT_FUNCTION_TEMPLATE);
     // Create package.json
     const packagePath = join(functionDir, 'package.json');
-    const packageContent = DEFAULT_PACKAGE_JSON.replace('<<NAME>>', name);
-    writeFileSync(packagePath, packageContent);
+    const packageContent = {
+        ...DEFAULT_PACKAGE_JSON,
+        name,
+        main: `index.${lang}`,
+    };
+    writeFileSync(packagePath, JSON.stringify(packageContent, null, 2));
+    // type looks like 'document-publish'
+    const typeParts = type.split('-');
+    const typeName = typeParts[0];
+    const eventOn = typeParts[1];
     // Create resource definition
     const resourceJson = {
         displayName,
         name,
-        type: `sanity.function.${type}`,
         src: `functions/${name}`,
+        type: `sanity.function.${typeName}`,
+        event: {
+            on: [eventOn],
+        },
     };
     // Add to blueprint or return for manual addition
     const resource = addResourceToBlueprint({ blueprintFilePath, resource: resourceJson });

package/dist/actions/blueprints/stacks.js

@@ -27,8 +27,6 @@ export async function getStack({ stackId, auth, }) {
     };
 }
 export async function createStack({ stackPayload, auth, }) {
-    // LAUNCH LIMIT: 1 Stack per Project
-    stackPayload.useProjectBasedId = true;
     const response = await fetch(stacksUrl, {
         method: 'POST',
         headers: getHeaders(auth),

package/dist/commands/blueprints/add.d.ts

@@ -7,13 +7,17 @@ export default class AddCommand extends Command {
     };
     static flags: {
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'function-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'fn-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        language: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        javascript: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     promptForFunctionName(): Promise<string>;
     promptForFunctionType(): Promise<string>;
-    addFunction({ name, type }: {
+    promptForFunctionLang(): Promise<string>;
+    addFunction({ name, type, lang, }: {
         name?: string;
         type?: string;
+        lang?: string;
     }): Promise<void>;
 }

package/dist/commands/blueprints/add.js

@@ -1,16 +1,18 @@
 import { cwd } from 'node:process';
 import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import highlight from 'color-json';
 import inquirer from 'inquirer';
 import { findBlueprintFile } from '../../actions/blueprints/blueprint.js';
 import { createFunctionResource } from '../../actions/blueprints/resources.js';
-import { validateFunctionName, validateFunctionType } from '../../utils/validate/resource.js';
+import { validateFunctionName } from '../../utils/validate/resource.js';
 export default class AddCommand extends Command {
-    static description = 'Add a resource to a Blueprint';
+    static description = 'Add a (function) resource to a Blueprint';
     static examples = [
         '<%= config.bin %> <%= command.id %> function',
         '<%= config.bin %> <%= command.id %> function --name my-function',
-        '<%= config.bin %> <%= command.id %> function --name my-function --function-type document-publish',
+        '<%= config.bin %> <%= command.id %> function --name my-function --fn-type document-publish',
+        '<%= config.bin %> <%= command.id %> function --name my-function --fn-type document-publish --lang js',
     ];
     static args = {
         type: Args.string({
@@ -24,11 +26,23 @@ export default class AddCommand extends Command {
             description: 'Name of the resource to add',
             char: 'n',
         }),
-        'function-type': Flags.string({
-            description: 'Type of function to add (e.g. document-publish)',
+        'fn-type': Flags.string({
+            description: 'Type of new function',
             options: ['document-publish' /*, 'document-create', 'document-delete'*/],
+            aliases: ['function-type'],
+            // default: 'document-publish', // prompting informs user of default
             dependsOn: ['name'],
         }),
+        language: Flags.string({
+            description: 'Language of the new function',
+            aliases: ['function-language', 'lang'],
+            options: ['ts', 'js'],
+            default: 'ts',
+        }),
+        javascript: Flags.boolean({
+            description: 'Use JavaScript instead of TypeScript',
+            aliases: ['js'],
+        }),
     };
     async run() {
         const { args, flags } = await this.parse(AddCommand);
@@ -38,9 +52,11 @@ export default class AddCommand extends Command {
         if (!existingBlueprint) {
             this.error('No Blueprint file found. Run `sanity-run blueprints init` first.');
         }
-        const resourceName = flags.name;
-        const functionType = flags['function-type'];
-        await this.addFunction({ name: resourceName, type: functionType });
+        const { name: resourceName, 'fn-type': functionType, javascript } = flags;
+        let { lang: functionLang } = flags;
+        if (javascript)
+            functionLang = 'js';
+        await this.addFunction({ name: resourceName, type: functionType, lang: functionLang });
     }
     async promptForFunctionName() {
         const { functionName } = await inquirer.prompt([
@@ -69,21 +85,41 @@ export default class AddCommand extends Command {
         ]);
         return functionType;
     }
-    async addFunction({ name, type }) {
+    async promptForFunctionLang() {
+        const { functionLang } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'functionLang',
+                message: 'Choose function language:',
+                choices: [
+                    { name: 'TypeScript', value: 'ts' },
+                    { name: 'JavaScript', value: 'js' },
+                ],
+                default: 'ts',
+            },
+        ]);
+        return functionLang;
+    }
+    async addFunction({ name, type, lang, }) {
         const functionName = name || (await this.promptForFunctionName());
         if (!validateFunctionName(functionName)) {
             this.error('Invalid function name. Must be 6+ characters, no special characters, no spaces');
         }
         const functionType = type || (await this.promptForFunctionType());
-        if (!validateFunctionType(functionType)) {
+        const functionLang = lang || (await this.promptForFunctionLang());
+        if (!['document-publish', 'document-create', 'document-delete'].includes(functionType)) {
             this.error('Invalid function type. Must be one of: document-publish, document-create, document-delete');
         }
         const { filePath, resourceAdded, resource } = createFunctionResource({
             name: functionName,
             type: functionType,
+            lang: functionLang,
             displayName: functionName,
         });
         this.log(`\nCreated function: ${filePath.replace(cwd(), '')}`);
+        if (functionLang === 'ts') {
+            this.log(chalk.dim('To avoid committing build artifacts, it is helpful to .gitignore "functions/**/.build/**"'));
+        }
         if (!resourceAdded) {
             // print the resource JSON for manual addition
             this.log('\nAdd this Function resource to your blueprint:');

package/dist/commands/blueprints/config.d.ts

@@ -9,6 +9,8 @@ export default class ConfigCommand extends Command {
         'stack-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     sanityToken: string | undefined;
+    projectId: string | undefined;
+    stackId: string | undefined;
     run(): Promise<void>;
     promptForProjectId({ knownProjectId }: {
         knownProjectId?: string;
@@ -17,11 +19,16 @@ export default class ConfigCommand extends Command {
         projectId: string;
         knownStackId?: string;
     }): Promise<string | undefined>;
-    testConfigAndReport({ stackId, projectId }: {
+    testConfigAndReport({ stackId, projectId, reinit, }: {
         stackId: string;
         projectId: string;
+        reinit?: boolean;
     }): Promise<{
         ok: boolean;
         error: string | null;
     }>;
+    startReinitializeStack({ projectId, stackId }: {
+        projectId: string;
+        stackId: string;
+    }): Promise<void>;
 }

package/dist/commands/blueprints/config.js

@@ -1,10 +1,11 @@
 import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import highlight from 'color-json';
 import inquirer from 'inquirer';
 import Spinner from 'yocto-spinner';
 import { readLocalBlueprint, writeConfigFile } from '../../actions/blueprints/blueprint.js';
-import { listProjects } from '../../actions/blueprints/projects.js';
-import { getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import { getProject, listProjects } from '../../actions/blueprints/projects.js';
+import { createStack, getStack, listStacks } from '../../actions/blueprints/stacks.js';
 import { bold, dim, niceId } from '../../utils/display/colors.js';
 import { presentBlueprintParserErrors } from '../../utils/display/errors.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
@@ -43,6 +44,8 @@ export default class ConfigCommand extends Command {
         }),
     };
     sanityToken;
+    projectId;
+    stackId;
     async run() {
         const { flags } = await this.parse(ConfigCommand);
         const { edit: editConfig, 'project-id': editProjectId, 'stack-id': editStackId, 'test-config': testConfig, } = flags;
@@ -84,22 +87,27 @@ export default class ConfigCommand extends Command {
         // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
         // const stackId =
         //   editStackId || (await this.promptForStackId({projectId, knownStackId: configStackId}))
-        const stackId = configStackId;
+        let stackId = configStackId;
         if (testConfig) {
             if (projectId && stackId) {
-                const { ok: newConfigOk } = await this.testConfigAndReport({ stackId, projectId });
-                if (!newConfigOk) {
+                const { ok: newConfigOk } = await this.testConfigAndReport({
+                    stackId,
+                    projectId,
+                    reinit: editConfig,
+                });
+                if (!newConfigOk)
                     this.error('Updated configuration has not been saved.');
-                }
             }
             else {
                 this.error('Unable to test the configuration. Both Project and Stack IDs must be set.');
             }
         }
+        // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+        if (stackId?.endsWith(projectId))
+            stackId = undefined;
         try {
             // update or create .blueprint/config.json
-            // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
-            writeConfigFile({ projectId /*, stackId*/ });
+            writeConfigFile({ projectId, stackId });
             this.log('Configuration updated successfully.');
         }
         catch (error) {
@@ -159,7 +167,7 @@ export default class ConfigCommand extends Command {
         }
         return undefined;
     }
-    async testConfigAndReport({ stackId, projectId }) {
+    async testConfigAndReport({ stackId, projectId, reinit = false, }) {
         if (!this.sanityToken)
             this.error('Unable to test the configuration. Missing API token.');
         const spinner = Spinner({ text: 'Testing the configuration...' }).start();
@@ -168,12 +176,41 @@ export default class ConfigCommand extends Command {
             auth: { token: this.sanityToken, projectId },
         });
         if (!ok) {
-            spinner.error(error ?? 'Unknown error testing the configuration');
-            this.log('Use the --edit flag to interactively update the configuration.');
+            spinner.error('Blueprint deployment not found');
+            // check if configured project and stack can be reinitialized
+            if (reinit && stackId === `ST-${projectId}`) {
+                await this.startReinitializeStack({ projectId, stackId });
+                return { ok: true, error: null };
+            }
         }
         else {
             spinner.success('Configuration is valid.');
         }
         return { ok, error };
     }
+    async startReinitializeStack({ projectId, stackId }) {
+        if (!this.sanityToken)
+            this.error('Unable to reinitialize the Stack. Missing API token.');
+        const auth = { token: this.sanityToken, projectId };
+        // stack id IS ST-${projectId} – it has already been checked and doesn't exist
+        this.log(`A new Blueprint deployment can be created with the ${chalk.bold('existing')} configuration.`);
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Do you want to create a ${chalk.blue('new')}, empty Blueprint deployment with the ${chalk.blue('existing')} configuration?`,
+            },
+        ]);
+        if (!confirm)
+            this.error('Reinitialization cancelled.');
+        const { ok: projectOk, project } = await getProject(auth);
+        if (!projectOk)
+            this.error('Failed to find Project while creating Stack');
+        const projectDisplayName = project.displayName;
+        const stackPayload = { name: projectDisplayName, projectId, document: { resources: [] } };
+        const response = await createStack({ stackPayload, auth });
+        if (!response.ok)
+            this.error(response.error || 'Failed to create new Stack');
+        this.log(`New Blueprint deployment created for "${projectDisplayName}"`);
+    }
 }

package/dist/commands/blueprints/destroy.js

@@ -6,7 +6,7 @@ import { destroyStack, getStack } from '../../actions/blueprints/stacks.js';
 import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { bold, niceId } from '../../utils/display/colors.js';
 export default class DestroyCommand extends DeployedBlueprintCommand {
-    static description = 'Destroy a Blueprint deployment';
+    static description = 'Destroy a Blueprint deployment (will not delete local files)';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set

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

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import type { AuthParams, Stack, StackPayload } from '../../utils/types.js';
+import type { AuthParams, Stack } from '../../utils/types.js';
 export default class InitCommand extends Command {
     static description: string;
     static examples: string[];
@@ -23,9 +23,10 @@ export default class InitCommand extends Command {
     promptForStackId({ projectId }: {
         projectId: string;
     }): Promise<string>;
-    createEmptyStack({ stackPayload, auth, }: {
-        stackPayload: StackPayload;
-        auth: AuthParams;
+    createEmptyStack({ projectId, name, projectBased, }: {
+        projectId: string;
+        name: string;
+        projectBased?: boolean;
     }): Promise<Stack>;
     createProjectBasedStack(auth: AuthParams): Promise<Stack>;
 }

package/dist/commands/blueprints/init.js

@@ -1,11 +1,12 @@
 import { join } from 'node:path';
 import { cwd } from 'node:process';
 import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { findBlueprintFile, writeBlueprintToDisk, writeConfigFile, } from '../../actions/blueprints/blueprint.js';
 import { getProject, listProjects } from '../../actions/blueprints/projects.js';
 import { createStack, getStack, listStacks } from '../../actions/blueprints/stacks.js';
-import { bold, dim, niceId, underline } from '../../utils/display/colors.js';
+import { niceId } from '../../utils/display/colors.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
 const LAUNCH_LIMIT_STACK_PER_PROJECT = true;
 export default class InitCommand extends Command {
@@ -47,7 +48,6 @@ export default class InitCommand extends Command {
         'stack-name': Flags.string({
             description: 'Name to use for a NEW Stack',
             aliases: ['name'],
-            dependsOn: ['project-id'],
             exclusive: ['stack-id'],
             hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
@@ -55,21 +55,18 @@ export default class InitCommand extends Command {
     sanityToken;
     async run() {
         const { args, flags } = await this.parse(InitCommand);
+        const { token, error: tokenErr } = await validTokenOrErrorMessage();
+        if (tokenErr)
+            this.error(tokenErr.message);
+        this.sanityToken = token;
         const { 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'stack-id': flagStackId, 'stack-name': flagStackName, dir: flagDir, } = flags;
         const { dir: argDir } = args;
         const dirProvided = argDir || flagDir;
         const here = cwd();
         const dir = argDir || flagDir || here;
         const existingBlueprint = findBlueprintFile(dir);
-        if (existingBlueprint) {
-            this.log(`A Blueprint file already exists: ${existingBlueprint.blueprintFilePath.replace(here, '')}`);
-            this.log('Use `sanity-run blueprints config --edit` to edit the configuration.');
+        if (existingBlueprint)
             this.error('Existing Blueprint found.');
-        }
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        this.sanityToken = token;
         const blueprintExtension = flagBlueprintType || (await this.promptForBlueprintType());
         if (!blueprintExtension)
             this.error('Blueprint type is required.');
@@ -80,23 +77,19 @@ export default class InitCommand extends Command {
             projectId = pickedProject.projectId;
         }
         const auth = { token: this.sanityToken, projectId };
-        // LAUNCH LIMIT: 1 Stack per Project - do not prompt for Stack, just create one
-        if (LAUNCH_LIMIT_STACK_PER_PROJECT) {
-            const stack = await this.createProjectBasedStack(auth);
+        if (flagStackName) {
+            // using --stack-name gets around "LAUNCH LIMIT: 1 Stack per Project"
+            const stack = await this.createEmptyStack({
+                projectId,
+                name: flagStackName,
+                projectBased: false,
+            });
             stackId = stack.id;
         }
-        // while LAUNCH_LIMIT_STACK_PER_PROJECT is true, the stackId is already set
-        if (!stackId) {
-            if (flagStackName) {
-                const stack = await this.createEmptyStack({
-                    stackPayload: { name: flagStackName, projectId, document: { resources: [] } },
-                    auth,
-                });
-                stackId = stack.id;
-            }
-            else {
-                stackId = await this.promptForStackId({ projectId });
-            }
+        // LAUNCH LIMIT: 1 Stack per Project - do not prompt for Stack, just create one
+        if (!stackId && LAUNCH_LIMIT_STACK_PER_PROJECT) {
+            const stack = await this.createProjectBasedStack(auth);
+            // stackId = stack.id
         }
         const fileName = `blueprint.${blueprintExtension}`;
         const filePath = join(dir, fileName);
@@ -104,8 +97,7 @@ export default class InitCommand extends Command {
             this.log(`New Blueprint created:   ${dirProvided}/`);
         writeBlueprintToDisk({ blueprintFilePath: filePath });
         this.log(`Created new blueprint:   ${dirProvided ?? '.'}/${fileName}`);
-        // LAUNCH LIMIT: 1 Stack per Project - do not persist stackId
-        writeConfigFile({ blueprintFilePath: filePath, projectId /*, stackId*/ });
+        writeConfigFile({ blueprintFilePath: filePath, projectId, stackId });
         this.log(`Created new config file: ${dirProvided ?? '.'}/.blueprint/config.json`);
         if (blueprintExtension === 'ts') {
             this.log('\nNote: TypeScript support requires "tsx" to be installed. Run: npm install -D tsx');
@@ -156,11 +148,13 @@ export default class InitCommand extends Command {
         const { ok: stacksOk, error: stacksErr, stacks, } = await listStacks({ token: this.sanityToken, projectId });
         if (!stacksOk)
             this.error(stacksErr || 'Failed to list Stacks');
-        const stackChoices = [{ name: bold('✨ Create a new Stack'), value: 'new' }];
+        const stackChoices = [
+            { name: chalk.bold('✨ Create a new Stack'), value: 'new' },
+        ];
         if (stacks.length > 0) {
-            stackChoices.push(new inquirer.Separator(underline('Use an existing Stack:')));
+            stackChoices.push(new inquirer.Separator(chalk.underline('Use an existing Stack:')));
             stackChoices.push(...stacks.map((s) => ({
-                name: `"${s.name}" ${niceId(s.id)} ${dim(`(${s.resources.length} res)`)}`,
+                name: `"${s.name}" ${niceId(s.id)} ${chalk.dim(`(${s.resources.length} res)`)}`,
                 value: s.id,
             })));
         }
@@ -181,15 +175,21 @@ export default class InitCommand extends Command {
                     validate: (input) => input.length > 0 || 'Stack name is required',
                 },
             ]);
-            const stack = await this.createEmptyStack({
-                stackPayload: { name: stackName, projectId, document: { resources: [] } },
-                auth: { token: this.sanityToken, projectId },
-            });
+            const stack = await this.createEmptyStack({ projectId, name: stackName });
             return stack.id;
         }
         return pickedStackId;
     }
-    async createEmptyStack({ stackPayload, auth, }) {
+    async createEmptyStack({ projectId, name, projectBased = true, }) {
+        if (!this.sanityToken)
+            this.error('Unable to create Stack. Missing API token.');
+        const stackPayload = {
+            name,
+            projectId,
+            useProjectBasedId: projectBased,
+            document: { resources: [] },
+        };
+        const auth = { token: this.sanityToken, projectId };
         const response = await createStack({ stackPayload, auth });
         if (!response.ok)
             this.error(response.error || 'Failed to create new Stack');
@@ -208,19 +208,12 @@ export default class InitCommand extends Command {
         const { stack: existingStack, ok: stackOk } = await getStack({ stackId: inferredStackId, auth });
         // if existing stack, return stack
         if (stackOk && existingStack) {
-            this.warn(`Found existing deployment for "${projectDisplayName}" Blueprint`);
-            this.warn('Deploying an empty Blueprint will override the existing deployment.');
+            this.log(chalk.red(`Found existing deployment for "${projectDisplayName}" Blueprint`));
+            this.log(chalk.red('Deploying an empty Blueprint will override the existing deployment.'));
             return existingStack;
         }
         // if not, create a stack
-        const stack = await this.createEmptyStack({
-            stackPayload: {
-                projectId,
-                name: projectDisplayName,
-                document: { resources: [] },
-            },
-            auth,
-        });
+        const stack = await this.createEmptyStack({ projectId, name: projectDisplayName });
         return stack;
     }
 }

package/dist/server/static/vendor/vendor.bundle.d.ts

@@ -877,7 +877,7 @@ declare class SelectionRange {
     the character before its position, 1 the character after, and 0
     means no association.
     */
-    get assoc(): 1 | 0 | -1;
+    get assoc(): 0 | 1 | -1;
     /**
     The bidirectional text level associated with this cursor, if
     any.
@@ -1274,8 +1274,8 @@ declare class FacetProvider {
     id: number;
     dynamicSlot(addresses: any): {
         create(state: any): number;
-        update(state: any, tr: any): 1 | 0;
-        reconfigure: (state: any, oldState: any) => 1 | 0;
+        update(state: any, tr: any): 0 | 1;
+        reconfigure: (state: any, oldState: any) => 0 | 1;
     };
 }
 declare class PrecExtension {

package/dist/utils/display/colors.js

@@ -1,4 +1,6 @@
 import chalk from 'chalk';
+// TODO: remove simple exports and use chalk directly
+// move compound styling like niceId to formatters
 export function bold(str) {
     return chalk.bold(str);
 }

package/dist/utils/types.d.ts

@@ -55,6 +55,11 @@ export interface LocalFunctionResource extends LocalResource {
     memory?: number;
     timeout?: number;
     env?: Record<string, string>;
+    event?: {
+        on: Array<string>;
+        filter?: string;
+        projection?: string;
+    };
 }
 export interface Stack {
     id: string;

package/dist/utils/validate/resource.d.ts

@@ -1,2 +1,4 @@
+import type { LocalFunctionResource } from '../types.js';
+import { type BlueprintParserError } from '../types.js';
 export declare function validateFunctionName(name: string): boolean;
-export declare function validateFunctionType(type: string): boolean;
+export declare function validateFunctionResource(resource: LocalFunctionResource): BlueprintParserError[];

package/dist/utils/validate/resource.js

@@ -1,8 +1,97 @@
+import { BlueprintParserErrorType } from '../types.js';
 export function validateFunctionName(name) {
     // must be 6+ characters, no special characters, no spaces, allow _ and -
     return /^[a-zA-Z0-9][a-zA-Z0-9_-]{5,}$/.test(name);
 }
-export function validateFunctionType(type) {
-    const functionType = type.replace('sanity.function.', '');
-    return ['document-publish', 'document-create', 'document-delete'].includes(functionType);
+export function validateFunctionResource(resource) {
+    const { name: fnName } = resource;
+    const msgPrefix = `Function "${fnName}":`;
+    const errors = [];
+    if (!validateFunctionName(resource.name)) {
+        errors.push({
+            message: `${msgPrefix} Function name must be at least 6 characters, start with a letter or number, and only contain letters, numbers, _ or -`,
+            type: BlueprintParserErrorType.InvalidProperty,
+        });
+    }
+    if (!resource.type.startsWith('sanity.function.')) {
+        errors.push({
+            message: `${msgPrefix} Resource type must start with "sanity.function."`,
+            type: BlueprintParserErrorType.InvalidType,
+        });
+    }
+    if (!resource.event || !Array.isArray(resource.event.on) || resource.event.on.length === 0) {
+        errors.push({
+            message: `${msgPrefix} event.on must be a non-empty array`,
+            type: BlueprintParserErrorType.MissingRequiredProperty,
+        });
+    }
+    else if (resource.event.on[0] !== 'publish') {
+        errors.push({
+            message: `${msgPrefix} First event.on value must be "publish"`,
+            type: BlueprintParserErrorType.InvalidValue,
+        });
+    }
+    if (resource.event?.filter && typeof resource.event.filter !== 'string') {
+        errors.push({
+            message: `${msgPrefix} event.filter must be a string`,
+            type: BlueprintParserErrorType.InvalidType,
+        });
+    }
+    if (resource.event?.projection && typeof resource.event.projection !== 'string') {
+        errors.push({
+            message: `${msgPrefix} event.projection must be a string`,
+            type: BlueprintParserErrorType.InvalidType,
+        });
+    }
+    if (resource.memory !== undefined) {
+        if (!Number.isInteger(resource.memory)) {
+            errors.push({
+                message: `${msgPrefix} memory must be an integer`,
+                type: BlueprintParserErrorType.InvalidType,
+            });
+        }
+        else if (resource.memory < 1 || resource.memory > 10) {
+            errors.push({
+                message: `${msgPrefix} memory must be between 1 and 10 (GB)`,
+                type: BlueprintParserErrorType.InvalidValue,
+            });
+        }
+    }
+    if (resource.timeout !== undefined) {
+        if (!Number.isInteger(resource.timeout)) {
+            errors.push({
+                message: `${msgPrefix} timeout must be an integer`,
+                type: BlueprintParserErrorType.InvalidType,
+            });
+        }
+        else if (resource.timeout < 5 || resource.timeout > 900) {
+            errors.push({
+                message: `${msgPrefix} timeout must be between 5 and 900 (seconds)`,
+                type: BlueprintParserErrorType.InvalidValue,
+            });
+        }
+    }
+    if (resource.env !== undefined) {
+        if (typeof resource.env !== 'object') {
+            errors.push({
+                message: `${msgPrefix} env must be an object`,
+                type: BlueprintParserErrorType.InvalidType,
+            });
+        }
+        else {
+            if (!Object.keys(resource.env).every((key) => typeof key === 'string')) {
+                errors.push({
+                    message: `${msgPrefix} All env keys must be strings`,
+                    type: BlueprintParserErrorType.InvalidFormat,
+                });
+            }
+            if (!Object.values(resource.env).every((value) => typeof value === 'string')) {
+                errors.push({
+                    message: `${msgPrefix} All env values must be strings`,
+                    type: BlueprintParserErrorType.InvalidFormat,
+                });
+            }
+        }
+    }
+    return errors;
 }

package/oclif.manifest.json

@@ -12,11 +12,12 @@
           "required": true
         }
       },
-      "description": "Add a resource to a Blueprint",
+      "description": "Add a (function) resource to a Blueprint",
       "examples": [
         "<%= config.bin %> <%= command.id %> function",
         "<%= config.bin %> <%= command.id %> function --name my-function",
-        "<%= config.bin %> <%= command.id %> function --name my-function --function-type document-publish"
+        "<%= config.bin %> <%= command.id %> function --name my-function --fn-type document-publish",
+        "<%= config.bin %> <%= command.id %> function --name my-function --fn-type document-publish --lang js"
       ],
       "flags": {
         "name": {
@@ -27,18 +28,46 @@
           "multiple": false,
           "type": "option"
         },
-        "function-type": {
+        "fn-type": {
+          "aliases": [
+            "function-type"
+          ],
           "dependsOn": [
             "name"
           ],
-          "description": "Type of function to add (e.g. document-publish)",
-          "name": "function-type",
+          "description": "Type of new function",
+          "name": "fn-type",
           "hasDynamicHelp": false,
           "multiple": false,
           "options": [
             "document-publish"
           ],
           "type": "option"
+        },
+        "language": {
+          "aliases": [
+            "function-language",
+            "lang"
+          ],
+          "description": "Language of the new function",
+          "name": "language",
+          "default": "ts",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "ts",
+            "js"
+          ],
+          "type": "option"
+        },
+        "javascript": {
+          "aliases": [
+            "js"
+          ],
+          "description": "Use JavaScript instead of TypeScript",
+          "name": "javascript",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -166,7 +195,7 @@
     "blueprints:destroy": {
       "aliases": [],
       "args": {},
-      "description": "Destroy a Blueprint deployment",
+      "description": "Destroy a Blueprint deployment (will not delete local files)",
       "examples": [
         "<%= config.bin %> <%= command.id %>"
       ],
@@ -320,9 +349,6 @@
           "aliases": [
             "name"
           ],
-          "dependsOn": [
-            "project-id"
-          ],
           "description": "Name to use for a NEW Stack",
           "exclusive": [
             "stack-id"
@@ -791,5 +817,5 @@
       ]
     }
   },
-  "version": "4.5.1"
+  "version": "5.0.1"
 }

package/package.json

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