@sanity/runtime-cli 4.5.0 → 4.5.1

package/dist/commands/blueprints/init.js

@@ -1,21 +1,33 @@
 import { join } from 'node:path';
 import { cwd } from 'node:process';
-import { Command, Flags } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import { findBlueprintFile, writeBlueprintToDisk, writeConfigFile, } from '../../actions/blueprints/blueprint.js';
-import { listProjects } from '../../actions/blueprints/projects.js';
-import { createStack, 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, underline } from '../../utils/display/colors.js';
 import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Init extends Command {
+const LAUNCH_LIMIT_STACK_PER_PROJECT = true;
+export default class InitCommand extends Command {
     static description = 'Initialize a new Blueprint';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> [directory]',
         '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts>',
-        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-id <stackId>',
-        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-name <stackName>',
+        '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId>',
+        // LAUNCH LIMIT: 1 Stack per Project - do not prompt for Stack, just create one
+        // '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-id <stackId>',
+        // '<%= config.bin %> <%= command.id %> --blueprint-type <json|js|ts> --project-id <projectId> --stack-name <stackName>',
     ];
+    static args = {
+        dir: Args.string({
+            description: 'Directory to create the Blueprint in',
+        }),
+    };
     static flags = {
+        dir: Flags.string({
+            description: 'Directory to create the Blueprint in',
+        }),
         'blueprint-type': Flags.string({
             description: 'Blueprint manifest type to use for the Blueprint',
             options: ['json', 'js', 'ts'],
@@ -30,22 +42,29 @@ export default class Init extends Command {
             aliases: ['stack', 'stackId'],
             dependsOn: ['project-id'],
             exclusive: ['stack-name'],
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
         'stack-name': Flags.string({
-            char: 'n',
             description: 'Name to use for a NEW Stack',
             aliases: ['name'],
             dependsOn: ['project-id'],
             exclusive: ['stack-id'],
+            hidden: true, // LAUNCH LIMIT: 1 Stack per Project
         }),
     };
     sanityToken;
     async run() {
-        const { flags } = await this.parse(Init);
-        const { 'blueprint-type': flagBlueprintType, 'project-id': flagProjectId, 'stack-id': flagStackId, 'stack-name': flagStackName, } = flags;
-        const existingBlueprint = findBlueprintFile();
+        const { args, flags } = await this.parse(InitCommand);
+        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(`A blueprint file already exists: ${existingBlueprint.fileName}`);
+            this.log(`A Blueprint file already exists: ${existingBlueprint.blueprintFilePath.replace(here, '')}`);
+            this.log('Use `sanity-run blueprints config --edit` to edit the configuration.');
+            this.error('Existing Blueprint found.');
         }
         const { token, error: tokenErr } = await validTokenOrErrorMessage();
         if (tokenErr)
@@ -54,15 +73,24 @@ export default class Init extends Command {
         const blueprintExtension = flagBlueprintType || (await this.promptForBlueprintType());
         if (!blueprintExtension)
             this.error('Blueprint type is required.');
-        const projectId = flagProjectId || (await this.promptForProjectId());
-        if (!projectId)
-            this.error('Project ID is required.');
+        let projectId = flagProjectId;
         let stackId = flagStackId;
+        if (!projectId) {
+            const pickedProject = await this.promptForProject();
+            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);
+            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: { token: this.sanityToken, projectId },
+                    auth,
                 });
                 stackId = stack.id;
             }
@@ -71,11 +99,14 @@ export default class Init extends Command {
             }
         }
         const fileName = `blueprint.${blueprintExtension}`;
-        const filePath = join(cwd(), fileName);
+        const filePath = join(dir, fileName);
+        if (dirProvided)
+            this.log(`New Blueprint created:   ${dirProvided}/`);
         writeBlueprintToDisk({ blueprintFilePath: filePath });
-        this.log(`Created new blueprint: ./${fileName}`);
-        writeConfigFile({ blueprintFilePath: filePath, projectId, stackId });
-        this.log('Created new config file: ./.blueprint/config.json');
+        this.log(`Created new blueprint:   ${dirProvided ?? '.'}/${fileName}`);
+        // LAUNCH LIMIT: 1 Stack per Project - do not persist 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');
         }
@@ -96,7 +127,7 @@ export default class Init extends Command {
         ]);
         return pickedBlueprintsType;
     }
-    async promptForProjectId() {
+    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 });
@@ -107,17 +138,17 @@ export default class Init extends Command {
         }
         const projectChoices = projects.map(({ displayName, id: projectId }) => ({
             name: `"${displayName}" ${niceId(projectId)}`,
-            value: projectId,
+            value: { projectId, displayName },
         }));
-        const { pickedProjectId } = await inquirer.prompt([
+        const { pickedProject } = await inquirer.prompt([
             {
                 type: 'list',
-                name: 'pickedProjectId',
+                name: 'pickedProject',
                 message: 'Select your Sanity project:',
                 choices: projectChoices,
             },
         ]);
-        return pickedProjectId;
+        return pickedProject;
     }
     async promptForStackId({ projectId }) {
         if (!this.sanityToken)
@@ -137,7 +168,7 @@ export default class Init extends Command {
             {
                 type: 'list',
                 name: 'pickedStackId',
-                message: 'Select your Blueprint Stack:',
+                message: 'Select an existing deployment or create a new one:',
                 choices: stackChoices,
             },
         ]);
@@ -161,7 +192,35 @@ export default class Init extends Command {
     async createEmptyStack({ stackPayload, auth, }) {
         const response = await createStack({ stackPayload, auth });
         if (!response.ok)
-            this.error(response.error || 'Failed to create Stack');
+            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.warn(`Found existing deployment for "${projectDisplayName}" Blueprint`);
+            this.warn('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,
+        });
+        return stack;
+    }
 }

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

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

package/dist/commands/blueprints/logs.js

@@ -1,13 +1,12 @@
-import { Command, Flags } from '@oclif/core';
+import { Flags } from '@oclif/core';
 import Spinner from 'yocto-spinner';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 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 { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Logs extends Command {
-    static description = 'Display logs for a Blueprint stack';
+export default class LogsCommand extends DeployedBlueprintCommand {
+    static description = 'Display logs for a Blueprint deployment';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --watch',
@@ -21,32 +20,20 @@ export default class Logs extends Command {
         }),
     };
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { flags } = await this.parse(Logs);
-        const watchMode = flags.watch;
+        const flags = this.flags;
+        const spinner = Spinner({
+            text: `Fetching recent logs for deployment ${niceId(this.stackId)}`,
+        }).start();
         try {
-            const { errors, deployedStack } = await readBlueprintOnDisk({ getStack: true, token });
-            if (errors.length > 0) {
-                this.log('Blueprint parse errors:');
-                console.dir(errors, { depth: null });
-                return;
-            }
-            if (!deployedStack)
-                this.error('Stack not found'); // returns
-            const { id: stackId, projectId, name } = deployedStack;
-            const auth = { token, projectId };
-            const spinner = Spinner({ text: `Fetching logs for stack ${niceId(stackId)}` }).start();
-            if (watchMode) {
-                const { ok, logs, error } = await getLogs(stackId, auth);
+            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(); // stop and remove the spinner
-                this.log(`${formatTitle('Blueprint', name)} ${niceId(stackId)} logs`);
+                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);
@@ -55,7 +42,7 @@ export default class Logs extends Command {
                     }
                 }
                 else {
-                    this.log(`No recent logs found for stack ${niceId(stackId)}`);
+                    this.log(`No recent logs found for deployment ${niceId(this.stackId)}`);
                 }
                 const onOpen = () => {
                     this.log(`Watching for new logs... ${bold('ctrl+c')} to stop`);
@@ -67,24 +54,23 @@ export default class Logs extends Command {
                     newestTimestamp = new Date(log.timestamp).getTime();
                     this.log(formatLogEntry(log, true));
                 };
-                this.debug(`Connecting to streaming endpoint for Stack ${niceId(stackId)}...`);
-                streamLogs(stackId, auth, renderLog, onOpen, (error) => this.log(`${red('Error:')} ${error}`));
+                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(stackId, auth);
+            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 stack ${stackId}`);
+                spinner.info(`No logs found for deployment ${this.stackId}`);
                 return;
             }
-            spinner.success(`${formatTitle('Blueprint', name)} Logs`);
-            this.log(`Found ${bold(logs.length.toString())} log entries for Stack ${niceId(stackId)}\n`);
+            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));

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

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class Plan extends Command {
+import { BlueprintCommand } from '../../baseCommands.js';
+export default class PlanCommand extends BlueprintCommand<typeof PlanCommand> {
     static description: string;
     static examples: string[];
     run(): Promise<void>;

package/dist/commands/blueprints/plan.js

@@ -1,26 +1,20 @@
-import { Command } from '@oclif/core';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
+import { BlueprintCommand } from '../../baseCommands.js';
 import { formatResourceTree, formatTitle } from '../../utils/display/blueprints-formatting.js';
-import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Plan extends Command {
+import { presentBlueprintParserErrors } from '../../utils/display/errors.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 { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { errors, projectId, stackId, parsedBlueprint: { resources }, fileInfo, deployedStack, } = await readBlueprintOnDisk({ getStack: true, token });
+        const { parsedBlueprint, fileInfo, errors } = this.blueprint;
+        const { resources } = parsedBlueprint;
         if (errors.length > 0) {
-            // printErrors(errors)
-            this.log('Blueprint parse errors:');
-            console.dir(errors, { depth: null });
+            this.log(presentBlueprintParserErrors(errors));
+            // continue to show plan
         }
-        if (!projectId)
-            this.log('Blueprint must contain a project resource');
-        const name = deployedStack?.name ?? stackId ?? 'Unknown';
-        this.log(`${formatTitle('Stack', name)} Plan`);
+        // TODO: compare local to existingStack
+        this.log(`${formatTitle('Deployment', 'Plan')}`);
         this.log(`(${fileInfo.fileName})\n`);
         this.log(formatResourceTree(resources));
-        this.log('\nRun `sanity blueprints deploy` to deploy these changes');
+        this.log('\nRun `sanity-run blueprints deploy` to deploy these changes');
     }
 }

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

@@ -1,5 +1,6 @@
-import { Command } from '@oclif/core';
-export default class Stacks extends Command {
+import { BlueprintCommand } from '../../baseCommands.js';
+export default class StacksCommand extends BlueprintCommand<typeof StacksCommand> {
+    static hidden: boolean;
     static description: string;
     static examples: string[];
     static flags: {

package/dist/commands/blueprints/stacks.js

@@ -1,10 +1,11 @@
-import { Command, Flags } from '@oclif/core';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
+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 { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Stacks extends Command {
+export default class StacksCommand extends BlueprintCommand {
+    // LAUNCH LIMIT: 1 Stack per Project - hide stacks command
+    static hidden = true;
     static description = 'List all Blueprint stacks';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
@@ -17,34 +18,14 @@ export default class Stacks extends Command {
         }),
     };
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { flags } = await this.parse(Stacks);
-        let { projectId } = flags;
-        let stackId;
-        if (!projectId) {
-            try {
-                const { errors, projectId: projectIdFromBlueprint, stackId: stackIdFromBlueprint, } = await readBlueprintOnDisk();
-                if (errors.length > 0) {
-                    this.log('Blueprint parse errors:');
-                    console.dir(errors, { depth: null });
-                    return;
-                }
-                projectId = projectIdFromBlueprint;
-                stackId = stackIdFromBlueprint;
-            }
-            catch {
-                // continue to print error
-            }
-        }
+        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 blueprints init`');
+            this.log('Or create a Blueprint with `sanity-run blueprints init`');
             return;
         }
-        const auth = { token, projectId };
-        const { ok, stacks, error } = await listStacks(auth);
+        const { ok, stacks, error } = await listStacks({ token: this.sanityToken, projectId });
         if (!ok)
             this.error(error || 'Failed to list stacks');
         if (!stacks || stacks.length === 0) {
@@ -52,6 +33,6 @@ export default class Stacks extends Command {
             return;
         }
         this.log(`${bold('Project')} ${niceId(projectId)} ${bold('Stacks')}:\n`);
-        this.log(formatStacksListing(stacks, stackId));
+        this.log(formatStacksListing(stacks, this.blueprint.stackId));
     }
 }

package/dist/commands/functions/env/add.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class Add extends Command {
+import { DeployedBlueprintCommand } from '../../../baseCommands.js';
+export default class EnvAddCommand extends DeployedBlueprintCommand<typeof EnvAddCommand> {
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         key: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;

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

@@ -1,11 +1,10 @@
-import { Args, Command } from '@oclif/core';
+import { Args } from '@oclif/core';
 import Spinner from 'yocto-spinner';
-import { readBlueprintOnDisk } from '../../../actions/blueprints/blueprint.js';
 import { update } from '../../../actions/functions/env/update.js';
+import { DeployedBlueprintCommand } from '../../../baseCommands.js';
 import { red } from '../../../utils/display/colors.js';
 import { findFunctionByName } from '../../../utils/find-function.js';
-import { validTokenOrErrorMessage } from '../../../utils/validated-token.js';
-export default class Add extends Command {
+export default class EnvAddCommand extends DeployedBlueprintCommand {
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
         key: Args.string({ description: 'The name of the environment variable', required: true }),
@@ -16,22 +15,12 @@ export default class Add extends Command {
         '<%= config.bin %> <%= command.id %> MyFunction API_URL https://api.example.com/',
     ];
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { args } = await this.parse(Add);
+        const args = this.args;
         const spinner = Spinner({
             text: `Updating "${args.key}" environment variable in "${args.name}"`,
         }).start();
-        const { deployedStack } = await readBlueprintOnDisk({ getStack: true, token });
-        if (!deployedStack)
-            this.error('Stack not found'); // returns
-        const { projectId } = deployedStack;
-        const { externalId } = findFunctionByName(deployedStack, args.name);
-        const result = await update(externalId, args.key, args.value, {
-            token,
-            projectId,
-        });
+        const { externalId } = findFunctionByName(this.deployedStack, args.name);
+        const result = await update(externalId, args.key, args.value, this.auth);
         if (result.ok) {
             spinner.success(`Update of ${args.key} succeeded`);
         }

package/dist/commands/functions/env/list.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class List extends Command {
+import { DeployedBlueprintCommand } from '../../../baseCommands.js';
+export default class EnvListCommand extends DeployedBlueprintCommand<typeof EnvListCommand> {
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };

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

@@ -1,31 +1,24 @@
-import { Args, Command } from '@oclif/core';
-import { readBlueprintOnDisk } from '../../../actions/blueprints/blueprint.js';
+import { Args } from '@oclif/core';
+import Spinner from 'yocto-spinner';
 import { list } from '../../../actions/functions/env/list.js';
+import { DeployedBlueprintCommand } from '../../../baseCommands.js';
 import { findFunctionByName } from '../../../utils/find-function.js';
-import { validTokenOrErrorMessage } from '../../../utils/validated-token.js';
-export default class List extends Command {
+export default class EnvListCommand extends DeployedBlueprintCommand {
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
     };
     static description = 'List the environment variables for a Sanity function';
     static examples = ['<%= config.bin %> <%= command.id %> MyFunction'];
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { args } = await this.parse(List);
-        const { deployedStack } = await readBlueprintOnDisk({ getStack: true, token });
-        if (!deployedStack)
-            this.error('Stack not found. Is it deployed?'); // returns
-        const { projectId } = deployedStack;
-        const { externalId } = findFunctionByName(deployedStack, args.name);
-        const result = await list(externalId, {
-            token,
-            projectId,
-        });
+        const args = this.args;
+        const spinner = Spinner({ text: `Listing environment variables for "${args.name}"` }).start();
+        const { externalId } = findFunctionByName(this.deployedStack, args.name);
+        const result = await list(externalId, this.auth);
         if (!result.ok) {
+            spinner.stop().clear();
             this.error(`Error: ${result.error || 'Unknown error'}`);
         }
+        spinner.success(`Environment variables for "${args.name}"`);
         for (const key of result.envvars) {
             this.log(key);
         }

package/dist/commands/functions/env/remove.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class Remove extends Command {
+import { DeployedBlueprintCommand } from '../../../baseCommands.js';
+export default class EnvRemoveCommand extends DeployedBlueprintCommand<typeof EnvRemoveCommand> {
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         key: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;

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

@@ -1,11 +1,10 @@
-import { Args, Command } from '@oclif/core';
+import { Args } from '@oclif/core';
 import Spinner from 'yocto-spinner';
-import { readBlueprintOnDisk } from '../../../actions/blueprints/blueprint.js';
 import { remove } from '../../../actions/functions/env/remove.js';
+import { DeployedBlueprintCommand } from '../../../baseCommands.js';
 import { red } from '../../../utils/display/colors.js';
 import { findFunctionByName } from '../../../utils/find-function.js';
-import { validTokenOrErrorMessage } from '../../../utils/validated-token.js';
-export default class Remove extends Command {
+export default class EnvRemoveCommand extends DeployedBlueprintCommand {
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
         key: Args.string({ description: 'The name of the environment variable', required: true }),
@@ -13,22 +12,12 @@ export default class Remove extends Command {
     static description = 'Remove an environment variable for a Sanity function';
     static examples = ['<%= config.bin %> <%= command.id %> MyFunction API_URL'];
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { args } = await this.parse(Remove);
+        const args = this.args;
         const spinner = Spinner({
             text: `Removing "${args.key}" environment variable in "${args.name}"`,
         }).start();
-        const { deployedStack } = await readBlueprintOnDisk({ getStack: true, token });
-        if (!deployedStack)
-            this.error('Stack not found'); // returns
-        const { projectId } = deployedStack;
-        const { externalId } = findFunctionByName(deployedStack, args.name);
-        const result = await remove(externalId, args.key, {
-            token,
-            projectId,
-        });
+        const { externalId } = findFunctionByName(this.deployedStack, args.name);
+        const result = await remove(externalId, args.key, this.auth);
         if (result.ok) {
             spinner.success(`Removal of ${args.key} succeeded`);
         }

package/dist/commands/functions/invoke.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class Invoke extends Command {
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
+export default class InvokeCommand extends DeployedBlueprintCommand<typeof InvokeCommand> {
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };

package/dist/commands/functions/invoke.js

@@ -1,11 +1,10 @@
-import { Args, Command, Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import Spinner from 'yocto-spinner';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 import { invoke } from '../../actions/functions/invoke.js';
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { red } from '../../utils/display/colors.js';
 import { findFunctionByName } from '../../utils/find-function.js';
-import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Invoke extends Command {
+export default class InvokeCommand extends DeployedBlueprintCommand {
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
     };
@@ -23,17 +22,11 @@ export default class Invoke extends Command {
         }),
     };
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { args, flags } = await this.parse(Invoke);
+        const args = this.args;
+        const flags = this.flags;
         const spinner = Spinner({ text: `Invoking function "${args.name}"` }).start();
-        const { deployedStack } = await readBlueprintOnDisk({ getStack: true, token });
-        if (!deployedStack)
-            this.error('Stack not found'); // returns
-        const { projectId } = deployedStack;
-        const { externalId } = findFunctionByName(deployedStack, args.name);
-        const result = await invoke(externalId, { data: flags.data, file: flags.file }, { token, projectId });
+        const { externalId } = findFunctionByName(this.deployedStack, args.name);
+        const result = await invoke(externalId, { data: flags.data, file: flags.file }, this.auth);
         if (result.ok) {
             spinner.success(`Invocation of ${args.name} succeeded`);
             if (result.json?.data?.type === 'Buffer') {