@sanity/runtime-cli 4.5.0 → 5.0.0

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.d.ts

@@ -6,18 +6,6 @@ interface ListStacksResponse {
     stacks: Stack[];
 }
 export declare function listStacks(auth: AuthParams): Promise<ListStacksResponse>;
-interface GetStackByNameResponse {
-    ok: boolean;
-    error: string | null;
-    stack: Stack | null;
-    stackId: string | null;
-    availableStacks?: string[];
-}
-/** @deprecated Use getStack instead */
-export declare function getStackByName({ name, auth, }: {
-    name: string;
-    auth: AuthParams;
-}): Promise<GetStackByNameResponse>;
 interface GetStackResponse {
     ok: boolean;
     error: string | null;

package/dist/actions/blueprints/stacks.js

@@ -14,35 +14,6 @@ export async function listStacks(auth) {
         stacks,
     };
 }
-/** @deprecated Use getStack instead */
-export async function getStackByName({ name, auth, }) {
-    const { ok, stacks, error } = await listStacks(auth);
-    if (!ok || !stacks) {
-        return {
-            ok: false,
-            error: error || 'Failed to retrieve stacks',
-            stack: null,
-            stackId: null,
-        };
-    }
-    const foundStack = stacks.find((stack) => stack.name === name);
-    if (!foundStack) {
-        return {
-            ok: true,
-            error: null,
-            stack: null,
-            stackId: null,
-            availableStacks: stacks.map((s) => s.name),
-        };
-    }
-    const stackResult = await getStack({ stackId: foundStack.id, auth });
-    return {
-        ok: stackResult.ok,
-        error: stackResult.error,
-        stack: stackResult.stack,
-        stackId: foundStack.id,
-    };
-}
 export async function getStack({ stackId, auth, }) {
     const response = await fetch(`${stacksUrl}/${stackId}`, {
         method: 'GET',
@@ -64,7 +35,7 @@ export async function createStack({ stackPayload, auth, }) {
     const stack = await response.json();
     return {
         ok: response.ok,
-        error: response.ok ? null : stack.message,
+        error: response.ok ? null : stack.message || stack.error,
         stack,
     };
 }

package/dist/baseCommands.d.ts

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+import type { Interfaces } from '@oclif/core';
+import { readLocalBlueprint } from './actions/blueprints/blueprint.js';
+import type { AuthParams, Stack } from './utils/types.js';
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BlueprintCommand)['baseFlags'] & T['flags']>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export declare abstract class BlueprintCommand<T extends typeof Command> extends Command {
+    protected sanityToken: string;
+    protected blueprint: Awaited<ReturnType<typeof readLocalBlueprint>>;
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    init(): Promise<void>;
+    protected catch(err: Error & {
+        exitCode?: number;
+    }): Promise<unknown>;
+    protected finally(_: Error | undefined): Promise<unknown>;
+}
+export declare abstract class DeployedBlueprintCommand<T extends typeof Command> extends BlueprintCommand<T> {
+    protected auth: AuthParams;
+    protected deployedStack: Stack;
+    protected projectId: string;
+    protected stackId: string;
+    init(): Promise<void>;
+}

package/dist/baseCommands.js

@@ -0,0 +1,69 @@
+// * https://oclif.io/docs/base_class
+import { Command } from '@oclif/core';
+import { readLocalBlueprint } from './actions/blueprints/blueprint.js';
+import { getStack } from './actions/blueprints/stacks.js';
+import { presentBlueprintParserErrors } from './utils/display/errors.js';
+import { validTokenOrErrorMessage } from './utils/validated-token.js';
+export class BlueprintCommand extends Command {
+    sanityToken;
+    blueprint;
+    flags;
+    args;
+    async init() {
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            enableJsonFlag: this.ctor.enableJsonFlag,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+        await super.init();
+        const { token, error: tokenErr } = await validTokenOrErrorMessage();
+        if (tokenErr)
+            this.error(tokenErr.message);
+        this.sanityToken = token;
+        const blueprint = await readLocalBlueprint();
+        if (blueprint.errors.length > 0) {
+            this.log(presentBlueprintParserErrors(blueprint.errors));
+            this.error('Blueprint parse errors.');
+        }
+        this.blueprint = blueprint;
+    }
+    async catch(err) {
+        // add any custom logic to handle errors from the command
+        // or simply return the parent class error handling
+        return super.catch(err);
+    }
+    async finally(_) {
+        // called after run and catch regardless of whether or not the command errored
+        return super.finally(_);
+    }
+}
+export class DeployedBlueprintCommand extends BlueprintCommand {
+    auth;
+    deployedStack;
+    projectId;
+    stackId;
+    async init() {
+        await super.init();
+        const { projectId, stackId } = this.blueprint;
+        if (!projectId)
+            this.error('Missing Project ID for Blueprint');
+        if (!stackId)
+            this.error('Missing Stack ID for Blueprint');
+        this.projectId = projectId;
+        this.stackId = stackId;
+        this.auth = { token: this.sanityToken, projectId };
+        const stackResponse = await getStack({ stackId, auth: this.auth });
+        if (!stackResponse.ok) {
+            this.error(stackResponse.error ?? 'Could not retrieve deployment info');
+        }
+        const { stack: deployedStack } = stackResponse;
+        if (!deployedStack) {
+            this.error('Unable to find deployed Stack. Run `sanity-run blueprints init`');
+        }
+        this.deployedStack = deployedStack;
+    }
+}

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

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class Add extends Command {
+export default class AddCommand extends Command {
     static description: string;
     static examples: string[];
     static args: {
@@ -7,13 +7,17 @@ export default class Add 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,15 +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';
-export default class Add extends Command {
-    static description = 'Add a resource to a Blueprint';
+export default class AddCommand extends Command {
+    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({
@@ -23,23 +26,37 @@ export default class Add 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(Add);
+        const { args, flags } = await this.parse(AddCommand);
+        if (args.type !== 'function')
+            this.error(`Unsupported Resource type: ${args.type}`);
         const existingBlueprint = findBlueprintFile();
         if (!existingBlueprint) {
-            this.error('No blueprint file found. Run `sanity blueprints init` first.');
+            this.error('No Blueprint file found. Run `sanity-run blueprints init` first.');
         }
-        if (args.type !== 'function')
-            this.error(`Unsupported resource type: ${args.type}`);
-        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([
@@ -68,21 +85,41 @@ export default class Add 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());
+        const functionLang = lang || (await this.promptForFunctionLang());
         if (!validateFunctionType(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}`);
+        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

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class Config extends Command {
+export default class ConfigCommand extends Command {
     static description: string;
     static examples: string[];
     static flags: {
@@ -9,6 +9,8 @@ export default class Config 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 Config 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,19 +1,23 @@
 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 { readBlueprintOnDisk, writeConfigFile } from '../../actions/blueprints/blueprint.js';
-import { listProjects } from '../../actions/blueprints/projects.js';
-import { getStack, listStacks } from '../../actions/blueprints/stacks.js';
+import { readLocalBlueprint, 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 } from '../../utils/display/colors.js';
+import { presentBlueprintParserErrors } from '../../utils/display/errors.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Config extends Command {
+export default class ConfigCommand extends Command {
     static description = 'View or edit Blueprint configuration';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --test-config',
         '<%= config.bin %> <%= command.id %> --edit',
-        '<%= config.bin %> <%= command.id %> --edit --project-id <projectId> --stack-id <stackId>',
+        '<%= config.bin %> <%= command.id %> --edit --project-id <projectId>',
+        // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+        // '<%= config.bin %> <%= command.id %> --edit --project-id <projectId> --stack-id <stackId>',
     ];
     static flags = {
         'test-config': Flags.boolean({
@@ -36,20 +40,27 @@ export default class Config extends Command {
             description: 'Update the Stack ID in the configuration. Requires --edit flag',
             aliases: ['stack', 'stackId'],
             dependsOn: ['edit'],
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
     sanityToken;
+    projectId;
+    stackId;
     async run() {
-        const { flags } = await this.parse(Config);
+        const { flags } = await this.parse(ConfigCommand);
         const { edit: editConfig, 'project-id': editProjectId, 'stack-id': editStackId, 'test-config': testConfig, } = flags;
-        const blueprint = await readBlueprintOnDisk();
-        const { stackId: configStackId, projectId: configProjectId } = blueprint;
+        const blueprint = await readLocalBlueprint();
+        const { stackId: configStackId, projectId: configProjectId, errors } = blueprint;
+        if (errors.length > 0) {
+            this.log(presentBlueprintParserErrors(errors));
+            this.error('Blueprint parse errors.');
+        }
         if (!configStackId && !configProjectId) {
-            this.error('Project and Stack configuration is missing! Use `blueprints init` to create a configuration.');
+            this.error('Project configuration is missing! Use `sanity-run blueprints init` to create a configuration.');
         }
         this.log(bold('Current configuration:'));
         this.log(`  Sanity Project:  ${niceId(configProjectId)}`);
-        this.log(`  Blueprint Stack: ${niceId(configStackId)}`);
+        this.log(`  Blueprint deployment: ${niceId(configStackId)}`);
         if ((editProjectId || editStackId) && !editConfig) {
             this.log('To update the configuration, use the --edit flag.');
             return;
@@ -73,18 +84,27 @@ export default class Config extends Command {
         const projectId = editProjectId || (await this.promptForProjectId({ knownProjectId: configProjectId }));
         if (!projectId)
             this.error('Project ID is required.');
-        const stackId = editStackId || (await this.promptForStackId({ projectId, knownStackId: configStackId }));
+        // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+        // const stackId =
+        //   editStackId || (await this.promptForStackId({projectId, knownStackId: 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
             writeConfigFile({ projectId, stackId });
@@ -92,7 +112,8 @@ export default class Config extends Command {
         }
         catch (error) {
             this.log('Unable to dynamically update config. Use these values in your blueprint:');
-            this.log(highlight(JSON.stringify({ metadata: { projectId, stackId } }, null, 2)));
+            // LAUNCH LIMIT: 1 Stack per Project - do not allow Stack ID to be set
+            this.log(highlight(JSON.stringify({ metadata: { projectId /*, stackId*/ } }, null, 2)));
         }
     }
     async promptForProjectId({ knownProjectId }) {
@@ -146,7 +167,7 @@ export default class Config 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();
@@ -155,12 +176,41 @@ export default class Config 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/deploy.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class Deploy extends Command {
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
+export default class DeployCommand extends DeployedBlueprintCommand<typeof DeployCommand> {
     static description: string;
     static examples: string[];
     static flags: {