@sanity/runtime-cli 5.1.0 → 5.2.0

package/dist/commands/blueprints/init.js

@@ -1,14 +1,6 @@
-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 { niceId } from '../../utils/display/colors.js';
+import { blueprintInitCore } from '../../cores/blueprints/init.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-const LAUNCH_LIMIT_STACK_PER_PROJECT = true;
 export default class InitCommand extends Command {
     static description = 'Initialize a new Blueprint';
     static examples = [
@@ -52,168 +44,19 @@ export default class InitCommand extends Command {
             hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
-    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.error('Existing Blueprint found.');
-        const blueprintExtension = flagBlueprintType || (await this.promptForBlueprintType());
-        if (!blueprintExtension)
-            this.error('Blueprint type is required.');
-        let projectId = flagProjectId;
-        let stackId = flagStackId;
-        if (!projectId) {
-            const pickedProject = await this.promptForProject();
-            projectId = pickedProject.projectId;
-        }
-        const auth = { token: this.sanityToken, projectId };
-        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;
-        }
-        // 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);
-        if (dirProvided)
-            this.log(`New Blueprint created:   ${dirProvided}/`);
-        writeBlueprintToDisk({ blueprintFilePath: filePath });
-        this.log(`Created new blueprint:   ${dirProvided ?? '.'}/${fileName}`);
-        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');
-        }
-    }
-    async promptForBlueprintType() {
-        const { pickedBlueprintsType } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'pickedBlueprintsType',
-                message: 'Choose a blueprint type:',
-                choices: [
-                    { name: 'JSON (Recommended)', value: 'json' },
-                    { name: 'JavaScript', value: 'js', disabled: true },
-                    { name: 'TypeScript', value: 'ts', disabled: true },
-                ],
-                default: 'json',
-            },
-        ]);
-        return pickedBlueprintsType;
-    }
-    async promptForProject() {
-        if (!this.sanityToken)
-            this.error('Unable to list projects. Missing API token.');
-        const { ok: projectsOk, error: projectsErr, projects, } = await listProjects({ token: this.sanityToken });
-        if (!projectsOk)
-            this.error(projectsErr ?? '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, displayName },
-        }));
-        const { pickedProject } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'pickedProject',
-                message: 'Select your Sanity project:',
-                choices: projectChoices,
-            },
-        ]);
-        return pickedProject;
-    }
-    async promptForStackId({ projectId }) {
-        if (!this.sanityToken)
-            this.error('Unable to list Stacks. Missing API token.');
-        const { ok: stacksOk, error: stacksErr, stacks, } = await listStacks({ token: this.sanityToken, projectId });
-        if (!stacksOk)
-            this.error(stacksErr || 'Failed to list Stacks');
-        const stackChoices = [
-            { name: chalk.bold('✨ Create a new Stack'), value: 'new' },
-        ];
-        if (stacks.length > 0) {
-            stackChoices.push(new inquirer.Separator(chalk.underline('Use an existing Stack:')));
-            stackChoices.push(...stacks.map((s) => ({
-                name: `"${s.name}" ${niceId(s.id)} ${chalk.dim(`(${s.resources.length} res)`)}`,
-                value: s.id,
-            })));
-        }
-        const { pickedStackId } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'pickedStackId',
-                message: 'Select an existing deployment or create a new one:',
-                choices: stackChoices,
-            },
-        ]);
-        if (pickedStackId === 'new') {
-            const { stackName } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'stackName',
-                    message: 'Enter a name for your Stack:',
-                    validate: (input) => input.length > 0 || 'Stack name is required',
-                },
-            ]);
-            const stack = await this.createEmptyStack({ projectId, name: stackName });
-            return stack.id;
-        }
-        return pickedStackId;
-    }
-    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');
-        return response.stack;
-    }
-    // LAUNCH LIMIT: 1 Stack per Project - create exclusive stack for project
-    async createProjectBasedStack(auth) {
-        const { projectId } = auth;
-        // get project
-        const { ok: projectOk, project } = await getProject(auth);
-        if (!projectOk)
-            this.error('Failed to find Project while creating Stack');
-        const projectDisplayName = project.displayName;
-        // check if project has a stack
-        const inferredStackId = `ST-${projectId}`;
-        const { stack: existingStack, ok: stackOk } = await getStack({ stackId: inferredStackId, auth });
-        // if existing stack, return stack
-        if (stackOk && existingStack) {
-            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({ projectId, name: projectDisplayName });
-        return stack;
+        const { success, error } = await blueprintInitCore({
+            bin: this.config.bin,
+            log: (message) => this.log(message),
+            token,
+            args,
+            flags,
+        });
+        if (!success)
+            this.error(error);
     }
 }

package/dist/commands/blueprints/logs.js

@@ -1,10 +1,6 @@
 import { Flags } from '@oclif/core';
-import Spinner from 'yocto-spinner';
-import { findNewestLogTimestamp, getLogs, getRecentLogs, isNewerLog, streamLogs, } from '../../actions/blueprints/logs.js';
 import { DeployedBlueprintCommand } from '../../baseCommands.js';
-import { formatTitle } from '../../utils/display/blueprints-formatting.js';
-import { bold, niceId, red } from '../../utils/display/colors.js';
-import { formatLogEntry, formatLogsByDay, organizeLogsByDay, } from '../../utils/display/logs-formatting.js';
+import { blueprintLogsCore } from '../../cores/blueprints/logs.js';
 export default class LogsCommand extends DeployedBlueprintCommand {
     static description = 'Display logs for a Blueprint deployment';
     static examples = [
@@ -15,70 +11,21 @@ export default class LogsCommand extends DeployedBlueprintCommand {
         watch: Flags.boolean({
             char: 'w',
             description: 'Watch for new logs (streaming mode)',
-            required: false,
-            default: false,
+            aliases: ['follow'],
         }),
     };
     async run() {
-        const flags = this.flags;
-        const spinner = Spinner({
-            text: `Fetching recent logs for deployment ${niceId(this.stackId)}`,
-        }).start();
-        try {
-            if (flags.watch) {
-                const { ok, logs, error } = await getLogs(this.stackId, this.auth);
-                if (!ok) {
-                    spinner.error(`${red('Failed')} to retrieve logs`);
-                    this.log(`Error: ${error || 'Unknown error'}`);
-                    return;
-                }
-                spinner.stop().clear();
-                this.log(`${formatTitle('Blueprint', this.deployedStack.name)} ${niceId(this.stackId)} logs`);
-                if (logs.length > 0) {
-                    this.log('\nMost recent logs:');
-                    const recentLogs = getRecentLogs(logs);
-                    for (const log of recentLogs) {
-                        this.log(`  ${formatLogEntry(log)}`);
-                    }
-                }
-                else {
-                    this.log(`No recent logs found for deployment ${niceId(this.stackId)}`);
-                }
-                const onOpen = () => {
-                    this.log(`Watching for new logs... ${bold('ctrl+c')} to stop`);
-                };
-                let newestTimestamp = findNewestLogTimestamp(logs);
-                const renderLog = (log) => {
-                    if (!isNewerLog(log, newestTimestamp))
-                        return;
-                    newestTimestamp = new Date(log.timestamp).getTime();
-                    this.log(formatLogEntry(log, true));
-                };
-                streamLogs(this.stackId, this.auth, renderLog, onOpen, (error) => this.log(`${red('Error:')} ${error}`));
-                return new Promise(() => {
-                    // hold the line until the user terminates with Ctrl+C
-                });
-            }
-            const { ok, logs, error } = await getLogs(this.stackId, this.auth);
-            if (!ok) {
-                spinner.error(`${red('Failed')} to retrieve logs`);
-                this.log(`Error: ${error || 'Unknown error'}`);
-                return;
-            }
-            if (logs.length === 0) {
-                spinner.info(`No logs found for deployment ${this.stackId}`);
-                return;
-            }
-            spinner.success(`${formatTitle('Blueprint', this.deployedStack.name)} Logs`);
-            this.log(`Found ${bold(logs.length.toString())} log entries for deployment ${niceId(this.stackId)}\n`);
-            // Organize and format logs by day
-            const logsByDay = organizeLogsByDay(logs);
-            this.log(formatLogsByDay(logsByDay));
-        }
-        catch (err) {
-            this.warn('Failed to retrieve logs');
-            if (err instanceof Error)
-                this.error(`Error: ${err.message}`);
-        }
+        const { success, streaming, error } = await blueprintLogsCore({
+            bin: this.config.bin,
+            log: (message) => this.log(message),
+            auth: this.auth,
+            stackId: this.stackId,
+            deployedStack: this.deployedStack,
+            flags: this.flags,
+        });
+        if (streaming)
+            return streaming;
+        if (!success)
+            this.error(error);
     }
 }

package/dist/commands/blueprints/plan.js

@@ -1,20 +1,15 @@
 import { BlueprintCommand } from '../../baseCommands.js';
-import { formatResourceTree, formatTitle } from '../../utils/display/blueprints-formatting.js';
-import { presentBlueprintParserErrors } from '../../utils/display/errors.js';
+import { blueprintPlanCore } from '../../cores/blueprints/plan.js';
 export default class PlanCommand extends BlueprintCommand {
     static description = 'Enumerate resources to be deployed - will not modify any resources';
     static examples = ['<%= config.bin %> <%= command.id %>'];
     async run() {
-        const { parsedBlueprint, fileInfo, errors } = this.blueprint;
-        const { resources } = parsedBlueprint;
-        if (errors.length > 0) {
-            this.log(presentBlueprintParserErrors(errors));
-            // continue to show plan
-        }
-        // TODO: compare local to existingStack
-        this.log(`${formatTitle('Deployment', 'Plan')}`);
-        this.log(`(${fileInfo.fileName})\n`);
-        this.log(formatResourceTree(resources));
-        this.log('\nRun `sanity-run blueprints deploy` to deploy these changes');
+        const { success, error } = await blueprintPlanCore({
+            bin: this.config.bin,
+            log: (message) => this.log(message),
+            blueprint: this.blueprint,
+        });
+        if (!success)
+            this.error(error);
     }
 }

package/dist/commands/blueprints/stacks.js

@@ -1,8 +1,6 @@
 import { Flags } from '@oclif/core';
-import { listStacks } from '../../actions/blueprints/stacks.js';
 import { BlueprintCommand } from '../../baseCommands.js';
-import { formatStacksListing } from '../../utils/display/blueprints-formatting.js';
-import { bold, niceId } from '../../utils/display/colors.js';
+import { blueprintStacksCore } from '../../cores/blueprints/stacks.js';
 export default class StacksCommand extends BlueprintCommand {
     // LAUNCH LIMIT: 1 Stack per Project - hide stacks command
     static hidden = true;
@@ -18,21 +16,14 @@ export default class StacksCommand extends BlueprintCommand {
         }),
     };
     async run() {
-        const flags = this.flags;
-        const projectId = flags.projectId || this.blueprint.projectId;
-        if (!projectId) {
-            this.log('Unable to determine Project ID. Provide one with --projectId');
-            this.log('Or create a Blueprint with `sanity-run blueprints init`');
-            return;
-        }
-        const { ok, stacks, error } = await listStacks({ token: this.sanityToken, projectId });
-        if (!ok)
-            this.error(error || 'Failed to list stacks');
-        if (!stacks || stacks.length === 0) {
-            this.warn('No stacks found');
-            return;
-        }
-        this.log(`${bold('Project')} ${niceId(projectId)} ${bold('Stacks')}:\n`);
-        this.log(formatStacksListing(stacks, this.blueprint.stackId));
+        const { success, error } = await blueprintStacksCore({
+            bin: this.config.bin,
+            log: (message) => this.log(message),
+            token: this.sanityToken,
+            blueprint: this.blueprint,
+            flags: this.flags,
+        });
+        if (!success)
+            this.error(error);
     }
 }

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

@@ -0,0 +1,13 @@
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintAddOptions extends CoreConfig {
+    args: {
+        type: string;
+    };
+    flags: {
+        name?: string;
+        'fn-type'?: string;
+        language?: string;
+        javascript?: boolean;
+    };
+}
+export declare function blueprintAddCore(options: BlueprintAddOptions): Promise<CoreResult>;

package/dist/cores/blueprints/add.js

@@ -0,0 +1,107 @@
+import { cwd } from 'node:process';
+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 } from '../../utils/validate/resource.js';
+export async function blueprintAddCore(options) {
+    const { bin = 'sanity', log, args, flags } = options;
+    const { type: resourceType } = args;
+    const { name: flagResourceName, 'fn-type': flagFnType, javascript: flagJs } = flags;
+    let { language: flagFnLang } = flags;
+    flagFnLang = flagJs ? 'js' : flagFnLang;
+    try {
+        if (resourceType !== 'function') {
+            return {
+                success: false,
+                error: `Unsupported Resource type: ${resourceType}`,
+            };
+        }
+        const existingBlueprint = findBlueprintFile();
+        if (!existingBlueprint) {
+            return {
+                success: false,
+                error: `No Blueprint file found. Run \`${bin} blueprints init\` first.`,
+            };
+        }
+        const fnName = flagResourceName || (await promptForFunctionName());
+        if (!validateFunctionName(fnName)) {
+            throw new Error('Invalid function name. Must be 6+ characters, no special characters, no spaces');
+        }
+        const fnType = flagFnType || (await promptForFunctionType());
+        const fnLang = flagFnLang || (await promptForFunctionLang());
+        if (!['document-publish', 'document-create', 'document-delete'].includes(fnType)) {
+            throw new Error('Invalid function type. Must be one of: document-publish, document-create, document-delete');
+        }
+        const { filePath, resourceAdded, resource } = createFunctionResource({
+            name: fnName,
+            type: fnType,
+            lang: fnLang,
+            displayName: fnName,
+        });
+        log(`\nCreated function: ${filePath.replace(cwd(), '')}`);
+        if (!resourceAdded) {
+            // print the resource JSON for manual addition
+            log('\nAdd this Function resource to your blueprint:');
+            log(highlight(JSON.stringify(resource, null, 2)));
+        }
+        else {
+            // added to blueprint.json
+            log(`Function "${chalk.bold(fnName)}" added to blueprint file.`);
+        }
+        if (fnLang === 'ts') {
+            log(chalk.dim('Add "functions/**/.build/**" to your .gitignore.'));
+        }
+        return { success: true };
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+async function promptForFunctionName() {
+    const { functionName } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'functionName',
+            message: 'Enter function name:',
+            validate: (input) => input.length > 0 || 'Function name is required',
+        },
+    ]);
+    return functionName;
+}
+async function promptForFunctionType() {
+    const { functionType } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'functionType',
+            message: 'Choose function type:',
+            choices: [
+                { name: 'Document Publish', value: 'document-publish' },
+                { name: 'Document Create', value: 'document-create', disabled: true },
+                { name: 'Document Delete', value: 'document-delete', disabled: true },
+            ],
+            default: 'document-publish',
+        },
+    ]);
+    return functionType;
+}
+async function 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;
+}

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

@@ -0,0 +1,13 @@
+import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
+import type { CoreConfig, CoreResult } from '../index.js';
+export interface BlueprintConfigOptions extends CoreConfig {
+    token: string;
+    blueprint: ReadBlueprintResult;
+    flags: {
+        'test-config'?: boolean;
+        edit?: boolean;
+        'project-id'?: string;
+        'stack-id'?: string;
+    };
+}
+export declare function blueprintConfigCore(options: BlueprintConfigOptions): Promise<CoreResult>;