@sanity/runtime-cli 5.0.4 → 5.2.0

package/dist/commands/blueprints/config.js

@@ -1,15 +1,7 @@
-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 { 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 ConfigCommand extends Command {
+import { Flags } from '@oclif/core';
+import { BlueprintCommand } from '../../baseCommands.js';
+import { blueprintConfigCore } from '../../cores/blueprints/config.js';
+export default class ConfigCommand extends BlueprintCommand {
     static description = 'View or edit Blueprint configuration';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
@@ -43,174 +35,15 @@ export default class ConfigCommand extends Command {
             hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
-    sanityToken;
-    projectId;
-    stackId;
     async run() {
-        const { flags } = await this.parse(ConfigCommand);
-        const { edit: editConfig, 'project-id': editProjectId, 'stack-id': editStackId, 'test-config': testConfig, } = flags;
-        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 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 deployment: ${niceId(configStackId)}`);
-        if ((editProjectId || editStackId) && !editConfig) {
-            this.log('To update the configuration, use the --edit flag.');
-            return;
-        }
-        if (!editConfig && !testConfig)
-            return;
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        this.sanityToken = token;
-        if (testConfig && !editConfig) {
-            if (configStackId && configProjectId) {
-                await this.testConfigAndReport({ stackId: configStackId, projectId: configProjectId });
-            }
-            else {
-                this.log('Unable to test the configuration. Both Project and Stack IDs must be set.');
-            }
-        }
-        if (!editConfig)
-            return;
-        const projectId = editProjectId || (await this.promptForProjectId({ knownProjectId: configProjectId }));
-        if (!projectId)
-            this.error('Project ID is required.');
-        // 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,
-                    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 });
-            this.log('Configuration updated successfully.');
-        }
-        catch (error) {
-            this.log('Unable to dynamically update config. Use these values in your blueprint:');
-            // 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 }) {
-        if (!this.sanityToken)
-            this.error('Unable to list projects. Missing API token.');
-        const { ok, projects, error } = await listProjects({ token: this.sanityToken });
-        if (!ok)
-            this.error(error ?? 'Unknown error listing projects');
-        if (projects.length === 0) {
-            this.error('No Sanity projects found. Use `npx sanity init` to create one.');
-        }
-        const projectChoices = projects.map(({ displayName, id: projectId }) => ({
-            name: `"${displayName}" ${niceId(projectId)}`,
-            value: projectId,
-        }));
-        const { pickedProjectId } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'pickedProjectId',
-                message: 'Select your Sanity project:',
-                choices: projectChoices,
-                default: knownProjectId,
-            },
-        ]);
-        return pickedProjectId;
-    }
-    async promptForStackId({ projectId, knownStackId, }) {
-        if (!this.sanityToken)
-            this.error('Unable to list Stacks. Missing API token.');
-        const auth = { token: this.sanityToken, projectId };
-        // get stacks for selected project
-        const { ok: stacksOk, stacks, error: stacksError } = await listStacks(auth);
-        if (!stacksOk)
-            this.error(stacksError ?? 'Unknown error listing stacks');
-        if (stacks.length > 0) {
-            const stackChoices = stacks.map((s) => ({
-                name: `"${s.name}" ${niceId(s.id)} ${dim(`(${s.resources.length} res)`)}`,
-                value: s.id,
-            }));
-            stackChoices.push({ name: 'Unset Stack association', value: 'unset' });
-            const { pickedStackId } = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'pickedStackId',
-                    message: 'Select a stack:',
-                    choices: stackChoices,
-                    default: knownStackId,
-                },
-            ]);
-            return pickedStackId === 'unset' ? undefined : pickedStackId;
-        }
-        return undefined;
-    }
-    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();
-        const { ok, error } = await getStack({
-            stackId,
-            auth: { token: this.sanityToken, projectId },
+        const { success, error } = await blueprintConfigCore({
+            bin: this.config.bin,
+            log: (message) => this.log(message),
+            blueprint: this.blueprint,
+            token: this.sanityToken,
+            flags: this.flags,
         });
-        if (!ok) {
-            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}"`);
+        if (!success)
+            this.error(error);
     }
 }

package/dist/commands/blueprints/deploy.js

@@ -1,11 +1,6 @@
-import { setTimeout } from 'node:timers/promises';
 import { Flags } from '@oclif/core';
-import Spinner from 'yocto-spinner';
-import { stashAsset } from '../../actions/blueprints/assets.js';
-import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
 import { DeployedBlueprintCommand } from '../../baseCommands.js';
-import { bold, niceId, red } from '../../utils/display/colors.js';
-import { isLocalFunctionResource } from '../../utils/types.js';
+import { blueprintDeployCore } from '../../cores/blueprints/deploy.js';
 export default class DeployCommand extends DeployedBlueprintCommand {
     static description = 'Deploy a Blueprint';
     static examples = [
@@ -19,69 +14,17 @@ export default class DeployCommand extends DeployedBlueprintCommand {
         }),
     };
     async run() {
-        const flags = this.flags;
-        const { resources } = this.blueprint.parsedBlueprint;
-        const validResources = resources?.filter((r) => r.type);
-        const functionResources = validResources?.filter(isLocalFunctionResource);
-        // First stash all function assets
-        if (functionResources?.length) {
-            for (const resource of functionResources) {
-                const fnSpinner = Spinner({ text: `Processing ${resource.name}...` }).start();
-                const result = await stashAsset({ resource, auth: this.auth });
-                if (result.success && result.assetId) {
-                    const src = resource.src;
-                    resource.src = result.assetId; // TODO: properly reference asset - for now, the API expects the assetId
-                    fnSpinner.success(`${resource.name} ${niceId(result.assetId)}`);
-                    this.log(`   Source: ${src}`);
-                }
-                else {
-                    fnSpinner.error(`Failed to process ${resource.name}`);
-                    this.log(`   Error: ${result.error}`);
-                    return;
-                }
-            }
-        }
-        const stackPayload = {
+        const { success, error } = await blueprintDeployCore({
+            bin: this.config.bin,
+            log: (message) => this.log(message),
+            auth: this.auth,
+            stackId: this.stackId,
             projectId: this.projectId,
-            name: this.deployedStack.name,
-            document: { resources: validResources },
-        };
-        const spinner = Spinner({ text: 'Deploying...' }).start();
-        const { ok: deployOk, stack, error: deployError, } = await updateStack({ stackId: this.stackId, stackPayload, auth: this.auth });
-        if (deployOk) {
-            spinner.success(`Deployment "${bold(stack.name)}" ${niceId(stack.id)} started!`);
-            if (!flags['no-wait']) {
-                const waitSpinner = Spinner({ text: 'Waiting for deployment to complete...' }).start();
-                while (true) {
-                    // TODO: watch logs and print those while polling
-                    const { ok, stack: currentStack } = await getStack({ stackId: stack.id, auth: this.auth });
-                    if (!ok) {
-                        waitSpinner.error('Failed to check deployment status');
-                        break;
-                    }
-                    const operation = currentStack.recentOperation;
-                    if (!operation) {
-                        waitSpinner.error('No operation found');
-                        break;
-                    }
-                    if (operation.status === 'COMPLETED') {
-                        waitSpinner.success('Deployment completed successfully');
-                        break;
-                    }
-                    if (operation.status === 'FAILED') {
-                        waitSpinner.error('Deployment failed');
-                        break;
-                    }
-                    await setTimeout(1000);
-                }
-            }
-            else {
-                this.log('Use `sanity-run blueprints info` to check status');
-            }
-        }
-        else {
-            spinner.error(`${red('Failed')} to update deployment`);
-            this.log(`Error: ${deployError || JSON.stringify(stack, null, 2) || 'Unknown error'}`);
-        }
+            deployedStack: this.deployedStack,
+            blueprint: this.blueprint,
+            flags: this.flags,
+        });
+        if (!success)
+            this.error(error);
     }
 }

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

@@ -1,11 +1,12 @@
-import { DeployedBlueprintCommand } from '../../baseCommands.js';
-export default class DestroyCommand extends DeployedBlueprintCommand<typeof DestroyCommand> {
+import { BlueprintCommand } from '../../baseCommands.js';
+export default class DestroyCommand extends BlueprintCommand<typeof DestroyCommand> {
     static description: string;
     static examples: string[];
     static flags: {
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        projectId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'stack-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/blueprints/destroy.js

@@ -1,11 +1,7 @@
-import { setTimeout } from 'node:timers/promises';
 import { Flags } from '@oclif/core';
-import inquirer from 'inquirer';
-import Spinner from 'yocto-spinner';
-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 {
+import { BlueprintCommand } from '../../baseCommands.js';
+import { blueprintDestroyCore } from '../../cores/blueprints/destroy.js';
+export default class DestroyCommand extends BlueprintCommand {
     static description = 'Destroy a Blueprint deployment (will not delete local files)';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
@@ -15,70 +11,34 @@ export default class DestroyCommand extends DeployedBlueprintCommand {
     static flags = {
         force: Flags.boolean({
             description: 'Force destroy (skip confirmation)',
+            aliases: ['f'],
             default: false,
         }),
-        projectId: Flags.string({
+        'project-id': Flags.string({
             description: 'Project associated with the Stack (defaults to current Project)',
-            dependsOn: ['id', 'force'],
+            aliases: ['projectId', 'project'],
+            dependsOn: ['stack-id', 'force'],
             hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
-        id: Flags.string({
+        'stack-id': Flags.string({
             description: 'Stack ID to destroy (defaults to current Stack)',
-            dependsOn: ['projectId', 'force'],
+            aliases: ['stackId', 'stack'],
             hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
+        'no-wait': Flags.boolean({
+            description: 'Do not wait for destruction to complete',
+            default: false,
+        }),
     };
     async run() {
-        const flags = this.flags;
-        if (flags.projectId && flags.id && flags.force) {
-            // just try to destroy it
-            const auth = { token: this.sanityToken, projectId: flags.projectId };
-            const { ok, error, stack } = await destroyStack({ stackId: flags.id, auth });
-            if (!ok)
-                this.error(error || 'Failed to destroy deployment');
-            this.log(`Deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
-            return;
-        }
-        let stack = this.deployedStack;
-        if (flags.id) {
-            const { ok, stack: foundStack, error } = await getStack({ stackId: flags.id, auth: this.auth });
-            if (!ok)
-                this.error(error || 'Failed to get stack');
-            stack = foundStack;
-        }
-        const destroySpinner = Spinner({
-            text: `Destroying ${bold(stack.name)} ${niceId(stack.id)}...`,
-            color: 'red',
+        const { success, error } = await blueprintDestroyCore({
+            bin: this.config.bin,
+            log: (message) => this.log(message),
+            token: this.sanityToken,
+            blueprint: this.blueprint,
+            flags: this.flags,
         });
-        if (!flags.force) {
-            const { confirm } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'confirm',
-                    message: `Are you sure you want to destroy stack "${stack.name}" ${niceId(stack.id)}?`,
-                    default: false,
-                },
-            ]);
-            if (!confirm) {
-                this.log('Deployment destruction cancelled');
-                return;
-            }
-            destroySpinner.start();
-            let i = 5;
-            while (i >= 0) {
-                destroySpinner.text = `Destroying deployment in ${bold((i--).toString())} seconds...`;
-                await setTimeout(1000);
-            }
-            destroySpinner.text = 'Destroying deployment 💥';
-            await setTimeout(500);
-        }
-        else {
-            destroySpinner.start();
-        }
-        const { ok, error } = await destroyStack({ stackId: stack.id, auth: this.auth });
-        if (!ok)
-            this.error(error || 'Failed to destroy deployment');
-        // TODO: update local config
-        destroySpinner.success(`Deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
+        if (!success)
+            this.error(error);
     }
 }

package/dist/commands/blueprints/info.js

@@ -1,8 +1,6 @@
 import { Flags } from '@oclif/core';
-import { getStack } from '../../actions/blueprints/stacks.js';
 import { DeployedBlueprintCommand } from '../../baseCommands.js';
-import { formatResourceTree, formatStackInfo } from '../../utils/display/blueprints-formatting.js';
-import { niceId } from '../../utils/display/colors.js';
+import { blueprintInfoCore } from '../../cores/blueprints/info.js';
 export default class InfoCommand extends DeployedBlueprintCommand {
     static description = 'Show information about a Blueprint deployment';
     static examples = [
@@ -17,21 +15,15 @@ export default class InfoCommand extends DeployedBlueprintCommand {
         }),
     };
     async run() {
-        const flags = this.flags;
-        const stackId = flags.id || this.stackId;
-        let stack = this.deployedStack;
-        if (flags.id) {
-            const existingStackResponse = await getStack({ stackId, auth: this.auth });
-            if (!existingStackResponse.ok) {
-                this.error(existingStackResponse.error ??
-                    `Could not retrieve deployment info for ${niceId(stackId)}`);
-            }
-            stack = existingStackResponse.stack;
-        }
-        this.log(formatStackInfo(stack, true));
-        if (stack.resources) {
-            this.log('');
-            this.log(formatResourceTree(stack.resources));
-        }
+        const { success, error } = await blueprintInfoCore({
+            bin: this.config.bin,
+            log: (message) => this.log(message),
+            auth: this.auth,
+            stackId: this.stackId,
+            deployedStack: this.deployedStack,
+            flags: this.flags,
+        });
+        if (!success)
+            this.error(error);
     }
 }

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

@@ -1,5 +1,4 @@
 import { Command } from '@oclif/core';
-import type { AuthParams, Stack } from '../../utils/types.js';
 export default class InitCommand extends Command {
     static description: string;
     static examples: string[];
@@ -13,20 +12,5 @@ export default class InitCommand extends Command {
         'stack-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'stack-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    sanityToken: string | undefined;
     run(): Promise<void>;
-    promptForBlueprintType(): Promise<string>;
-    promptForProject(): Promise<{
-        projectId: string;
-        displayName: string;
-    }>;
-    promptForStackId({ projectId }: {
-        projectId: string;
-    }): Promise<string>;
-    createEmptyStack({ projectId, name, projectBased, }: {
-        projectId: string;
-        name: string;
-        projectBased?: boolean;
-    }): Promise<Stack>;
-    createProjectBasedStack(auth: AuthParams): Promise<Stack>;
 }