@sanity/runtime-cli 1.6.0 → 1.8.1

package/dist/actions/blueprints/blueprint.js

@@ -13,7 +13,11 @@ const SUPPORTED_FILE_NAMES_IN_PRIORITY_ORDER = [
     'blueprint.cjs',
     'blueprint.ts',
 ];
-function findBlueprintFile(blueprintPath) {
+export const DEFAULT_BLUEPRINT_CONTENT = {
+    blueprintVersion: '2024-10-01',
+    resources: [],
+};
+export function findBlueprintFile(blueprintPath) {
     if (blueprintPath) {
         if (existsSync(blueprintPath)) {
             return { path: blueprintPath, fileName: blueprintPath, extension: extname(blueprintPath) };
@@ -28,31 +32,6 @@ function findBlueprintFile(blueprintPath) {
     }
     return null;
 }
-function readConfigFile(blueprintPath) {
-    if (blueprintPath) {
-        const blueprintDir = dirname(blueprintPath);
-        const configPath = join(blueprintDir, '.blueprint', 'config.json');
-        if (existsSync(configPath)) {
-            try {
-                const config = JSON.parse(readFileSync(configPath, 'utf8'));
-                return config || null;
-            }
-            catch (err) {
-                return null;
-            }
-        }
-    }
-    const configFilePath = join(cwd(), '.blueprint', 'config.json');
-    if (!existsSync(configFilePath))
-        return null;
-    try {
-        const config = JSON.parse(readFileSync(configFilePath, 'utf8'));
-        return config || null;
-    }
-    catch (err) {
-        return null;
-    }
-}
 export async function readBlueprintOnDisk({ blueprintPath, getStack, } = {}) {
     try {
         const blueprintFile = findBlueprintFile(blueprintPath);
@@ -160,25 +139,51 @@ export async function readBlueprintOnDisk({ blueprintPath, getStack, } = {}) {
         throw Error(`Unable to parse Blueprint file: ${err}`);
     }
 }
-/** @experimental */ // no, that's not a real JSDoc pragma
-export async function updateBlueprintMetadata({ blueprintPath, projectId, stackId, }) {
-    const blueprintFile = findBlueprintFile(blueprintPath);
-    if (!blueprintFile)
-        throw Error('Could not find Blueprint file');
-    const { path } = blueprintFile;
-    const blueprintString = readFileSync(path, 'utf8').toString();
-    const blueprint = JSON.parse(blueprintString);
-    blueprint.metadata = blueprint.metadata || {};
-    blueprint.metadata.projectId = projectId;
-    blueprint.metadata.stackId = stackId;
-    writeFileSync(path, JSON.stringify(blueprint, null, 2));
+export function writeBlueprintToDisk({ path, fileType, content = DEFAULT_BLUEPRINT_CONTENT, }) {
+    let blueprintContent;
+    switch (fileType) {
+        case 'json': {
+            blueprintContent = JSON.stringify(content, null, 2);
+            break;
+        }
+        case 'js':
+        case 'ts': {
+            blueprintContent = `export default function() {
+  return ${JSON.stringify(content)}
+}`;
+            break;
+        }
+    }
+    writeFileSync(path, blueprintContent);
+    return blueprintContent;
 }
-export function writeBlueprintConfig({ blueprintPath, projectId, stackId, }) {
-    const blueprintFile = findBlueprintFile(blueprintPath);
-    if (!blueprintFile)
-        throw Error('Could not find Blueprint file');
-    const { path } = blueprintFile;
-    const blueprintDir = dirname(path);
+export function readConfigFile(blueprintPath) {
+    if (blueprintPath) {
+        const blueprintDir = dirname(blueprintPath);
+        const configPath = join(blueprintDir, '.blueprint', 'config.json');
+        if (existsSync(configPath)) {
+            try {
+                const config = JSON.parse(readFileSync(configPath, 'utf8'));
+                return config || null;
+            }
+            catch (err) {
+                return null;
+            }
+        }
+    }
+    const configFilePath = join(cwd(), '.blueprint', 'config.json');
+    if (!existsSync(configFilePath))
+        return null;
+    try {
+        const config = JSON.parse(readFileSync(configFilePath, 'utf8'));
+        return config || null;
+    }
+    catch (err) {
+        return null;
+    }
+}
+export function writeConfigFile({ blueprintPath, projectId, stackId, }) {
+    const blueprintDir = blueprintPath ? dirname(blueprintPath) : cwd();
     const configDir = join(blueprintDir, '.blueprint');
     const configPath = join(configDir, 'config.json');
     if (!existsSync(configDir)) {
@@ -197,3 +202,19 @@ export function writeBlueprintConfig({ blueprintPath, projectId, stackId, }) {
     config.stackId = stackId;
     writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
+export function addResourceToBlueprint({ blueprintPath, resource, }) {
+    const blueprintFile = findBlueprintFile(blueprintPath);
+    if (!blueprintFile)
+        throw Error('Could not find Blueprint file');
+    const { path, extension } = blueprintFile;
+    // modify .json files directly
+    if (extension === '.json') {
+        const blueprintString = readFileSync(path, 'utf8').toString();
+        const blueprint = JSON.parse(blueprintString);
+        blueprint.resources = blueprint.resources || [];
+        blueprint.resources.push(resource);
+        writeFileSync(path, JSON.stringify(blueprint, null, 2));
+        return;
+    }
+    return resource;
+}

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

@@ -5,4 +5,7 @@ export declare function getLogs(stackId: string, projectId: string, token: strin
     ok: boolean;
     error: string | null;
 }>;
+export declare function findNewestLogTimestamp(logs: BlueprintLog[]): number;
+export declare function isNewerLog(log: BlueprintLog, timestamp: number): boolean;
+export declare function getRecentLogs(logs: BlueprintLog[], limit?: number): BlueprintLog[];
 export declare function streamLogs(stackId: string, projectId: string, token: string, onLog: (log: BlueprintLog) => void, onOpen: () => void, onError: (error: string) => void): () => void;

package/dist/actions/blueprints/logs.js

@@ -22,6 +22,30 @@ export async function getLogs(stackId, projectId, token) {
         logs: response.ok ? result : [],
     };
 }
+// Process logs to find the newest timestamp
+export function findNewestLogTimestamp(logs) {
+    let newestTimestamp = 0;
+    if (logs.length > 0) {
+        for (const log of logs) {
+            const timestamp = new Date(log.timestamp).getTime();
+            if (timestamp > newestTimestamp) {
+                newestTimestamp = timestamp;
+            }
+        }
+    }
+    return newestTimestamp;
+}
+// Check if a log is newer than a given timestamp
+export function isNewerLog(log, timestamp) {
+    const logTimestamp = new Date(log.timestamp).getTime();
+    return logTimestamp > timestamp;
+}
+// Get most recent logs, up to a limit
+export function getRecentLogs(logs, limit = 10) {
+    const sortedLogs = [...logs].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    return sortedLogs.slice(-limit);
+}
+// Create streaming logs connection
 export function streamLogs(stackId, projectId, token, onLog, onOpen, onError) {
     const url = new URL(`${logsUrl}/stream`);
     url.searchParams.append('stackId', stackId);

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

@@ -0,0 +1,5 @@
+export declare function listProjects(): Promise<{
+    ok: boolean;
+    error: any;
+    projects: any;
+}>;

package/dist/actions/blueprints/projects.js

@@ -0,0 +1,21 @@
+import config from '../../config.js';
+const { apiUrl, token } = config;
+function getHeaders() {
+    return {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+    };
+}
+const projectsUrl = `${apiUrl.toString()}v2021-06-07/projects`;
+export async function listProjects() {
+    const response = await fetch(projectsUrl, {
+        method: 'GET',
+        headers: getHeaders(),
+    });
+    const projects = await response.json();
+    return {
+        ok: response.ok,
+        error: response.ok ? null : projects.error?.message,
+        projects,
+    };
+}

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

@@ -0,0 +1,13 @@
+export interface FunctionResourceOptions {
+    name: string;
+    type: string;
+    displayName?: string;
+}
+/**
+ * Creates a new function resource file and adds it to the blueprint
+ */
+export declare function createFunctionResource(options: FunctionResourceOptions): {
+    filePath: string;
+    resourceAdded: boolean;
+    resource: Record<string, unknown>;
+};

package/dist/actions/blueprints/resources.js

@@ -0,0 +1,37 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { addResourceToBlueprint } from './blueprint.js';
+/**
+ * Creates a new function resource file and adds it to the blueprint
+ */
+export function createFunctionResource(options) {
+    const { name, type, displayName = name } = options;
+    // Ensure functions directory exists
+    const functionsDir = join(cwd(), 'functions');
+    if (!existsSync(functionsDir)) {
+        mkdirSync(functionsDir, { recursive: true });
+    }
+    // Create function file with default template
+    const functionPath = join(functionsDir, `${name}.js`);
+    const functionContent = `export async function handler (event) {
+  console.log(event)
+  return {event}
+}`;
+    writeFileSync(functionPath, functionContent);
+    // Create resource definition
+    const resourceJson = {
+        displayName,
+        name,
+        type: `sanity.function.${type}`,
+        src: `functions/${name}.js`,
+    };
+    // Add to blueprint or return for manual addition
+    const resource = addResourceToBlueprint({ resource: resourceJson });
+    return {
+        filePath: functionPath,
+        resourceAdded: !resource, // If resource is null, it was added to blueprint
+        resource: resource || resourceJson,
+    };
+}

package/dist/actions/blueprints/stacks.js

@@ -17,7 +17,7 @@ export async function listStacks({ projectId }) {
     const stacks = await response.json();
     return {
         ok: response.ok,
-        error: response.ok ? null : stacks.message,
+        error: response.ok ? null : stacks.error?.message,
         stacks,
     };
 }

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Add extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        type: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private addFunction;
+}

package/dist/commands/blueprints/add.js

@@ -0,0 +1,67 @@
+import { Args, Command } from '@oclif/core';
+import inquirer from 'inquirer';
+import { highlight } from 'tinyhighlight/picocolors';
+import { findBlueprintFile } from '../../actions/blueprints/blueprint.js';
+import { createFunctionResource } from '../../actions/blueprints/resources.js';
+export default class Add extends Command {
+    static description = 'Add a resource to a Blueprint';
+    static examples = ['<%= config.bin %> <%= command.id %> function'];
+    static args = {
+        type: Args.string({
+            description: 'Type of resource to add (e.g. function)',
+            options: ['function'],
+            required: true,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(Add);
+        const existingBlueprint = findBlueprintFile(undefined);
+        if (!existingBlueprint) {
+            this.error('No blueprint file found. Run `sanity blueprints init` first.');
+        }
+        if (args.type === 'function') {
+            await this.addFunction();
+            return;
+        }
+        this.error(`Unsupported resource type: ${args.type}`);
+    }
+    async addFunction() {
+        const { functionName } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'functionName',
+                message: 'Enter function name:',
+                validate: (input) => input.length > 0 || 'Function name is required',
+            },
+        ]);
+        const { functionType } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'functionType',
+                message: 'Choose function type:',
+                choices: [
+                    { name: 'Document Mutation', value: 'document-mutation' },
+                    { name: 'Document Publish', value: 'document-publish' },
+                    { name: 'Document Update', value: 'document-update' },
+                    { name: 'Document Delete', value: 'document-delete' },
+                ],
+                default: 'document-mutation',
+            },
+        ]);
+        const { filePath, resourceAdded, resource } = createFunctionResource({
+            name: functionName,
+            type: functionType,
+            displayName: functionName,
+        });
+        this.log(`\nCreated function: ${filePath}`);
+        if (!resourceAdded) {
+            // print the resource JSON for manual addition
+            this.log('\nAdd this Function resource to your blueprint:');
+            this.log(highlight(JSON.stringify(resource, null, 2)));
+        }
+        else {
+            // added to blueprint.json
+            this.log('Function resource added to blueprint');
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Config extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        edit: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/blueprints/config.js

@@ -0,0 +1,72 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { highlight } from 'tinyhighlight/picocolors';
+import { readConfigFile, writeConfigFile } from '../../actions/blueprints/blueprint.js';
+import { listProjects } from '../../actions/blueprints/projects.js';
+import { listStacks } from '../../actions/blueprints/stacks.js';
+export default class Config extends Command {
+    static description = 'View or edit Blueprint configuration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --edit',
+    ];
+    static flags = {
+        edit: Flags.boolean({
+            description: 'Edit the configuration',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Config);
+        const config = readConfigFile();
+        if (!config) {
+            this.error('No configuration found. Run `sanity blueprints init` first.');
+        }
+        this.log('\nCurrent configuration:');
+        this.log(highlight(JSON.stringify(config, null, 2)));
+        if (!flags.edit)
+            return;
+        const { ok, projects, error } = await listProjects();
+        if (!ok)
+            this.error(error);
+        if (projects.length === 0) {
+            this.error('No projects found. Please create a project in Sanity.io first.');
+        }
+        const projectChoices = projects.map(({ displayName, id }) => ({
+            name: `${displayName} <${id}>`,
+            value: id,
+        }));
+        const { projectId } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'projectId',
+                message: 'Select your Sanity project:',
+                choices: projectChoices,
+                default: config.projectId,
+            },
+        ]);
+        // get stacks for selected project
+        const { ok: stacksOk, stacks, error: stacksError } = await listStacks({ projectId });
+        if (!stacksOk)
+            this.error(stacksError);
+        let stackId;
+        if (stacks.length > 0) {
+            const stackChoices = stacks.map(({ name, id }) => ({
+                name: `${name} <${id}>`,
+                value: id,
+            }));
+            const { stackId: selectedStackId } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'stackId',
+                    message: 'Select a stack:',
+                    choices: stackChoices,
+                    default: config.stackId,
+                },
+            ]);
+            stackId = selectedStackId;
+        }
+        writeConfigFile({ projectId, stackId });
+        this.log('\nConfiguration updated successfully.');
+    }
+}

package/dist/commands/blueprints/deploy.js

@@ -1,10 +1,10 @@
 import { Command } from '@oclif/core';
 import inquirer from 'inquirer';
-import { readBlueprintOnDisk, writeBlueprintConfig } from '../../actions/blueprints/blueprint.js';
+import { Spinner } from 'picospinner';
+import { readBlueprintOnDisk, writeConfigFile } from '../../actions/blueprints/blueprint.js';
 import { createStack, updateStack } from '../../actions/blueprints/stacks.js';
 import { stashAsset } from '../../actions/blueprints/stash-asset.js';
 import { bold, green, red, yellow } from '../../utils/display/colors.js';
-import Spinner from '../../utils/spinner.js';
 export default class Deploy extends Command {
     static description = 'Deploy a Blueprint';
     static examples = ['<%= config.bin %> <%= command.id %>'];
@@ -46,23 +46,22 @@ export default class Deploy extends Command {
         }
         if (!name)
             this.error('Stack name is required');
-        const s = new Spinner();
-        const validResources = resources.filter((r) => r.kind);
-        const functionResources = validResources.filter((r) => r.type?.startsWith('sanity.function.'));
+        const validResources = resources.filter((r) => r.type);
+        const functionResources = validResources.filter((r) => r.type.startsWith('sanity.function.'));
         // First stash all function assets
         if (functionResources.length > 0) {
             for (const resource of functionResources) {
-                const fnSpinner = new Spinner();
-                fnSpinner.start(`Processing ${resource.name}...`);
+                const fnSpinner = new Spinner(`Processing ${resource.name}...`);
+                fnSpinner.start();
                 const result = await stashAsset({ resource, projectId });
                 if (result.success) {
                     const src = resource.src;
                     resource.src = result.assetId; // TODO: properly reference asset - for now, the API expects the assetId
-                    fnSpinner.stop(`${green('✓')} ${resource.name} <${yellow(result.assetId)}>`);
+                    fnSpinner.succeed(`${resource.name} <${yellow(result.assetId)}>`);
                     this.log(`   Source: ${src}`);
                 }
                 else {
-                    fnSpinner.stop(`${red('✗')} Failed to process ${resource.name}`);
+                    fnSpinner.fail(`Failed to process ${resource.name}`);
                     this.log(`   Error: ${result.error}`);
                     return;
                 }
@@ -74,13 +73,15 @@ export default class Deploy extends Command {
             document: { resources: validResources },
         };
         this.debug('BLUEPRINT DOCUMENT:', blueprint);
+        const spinner = new Spinner('Deploying stack...');
+        spinner.start();
         const { ok: deployOk, stack, error: deployError, } = deployedStack
             ? await updateStack({ stackId: deployedStack.id, blueprint, projectId })
             : await createStack({ blueprint, projectId });
         this.debug('STACK RESPONSE:', stack);
         if (deployOk) {
-            s.stop(`${green('Success!')} Stack "${bold(stack.name)}" ${deployedStack ? 'updated' : 'created'} <${yellow(stack.id)}>`);
-            writeBlueprintConfig({
+            spinner.succeed(`${green('Success!')} Stack "${bold(stack.name)}" ${deployedStack ? 'updated' : 'created'} <${yellow(stack.id)}>`);
+            writeConfigFile({
                 projectId,
                 stackId: stack.id,
             });
@@ -88,7 +89,7 @@ export default class Deploy extends Command {
         }
         else {
             this.debug('STACK ERROR RESPONSE:', stack);
-            s.stop(`${red('Failed')} to ${deployedStack ? 'update' : 'create'} stack`);
+            spinner.fail(`${red('Failed')} to ${deployedStack ? 'update' : 'create'} stack`);
             this.log(`Error: ${deployError || JSON.stringify(stack, null, 2) || 'Unknown error'}`);
         }
     }

package/dist/commands/blueprints/info.js

@@ -59,7 +59,7 @@ export default class Info extends Command {
                     this.log(`  Status: ${operationColor(status)}`);
                 }
                 if (operation.createdAt) {
-                    this.log(`  Started  : ${formatDate(operation.createdAt)}`);
+                    this.log(`  Started: ${formatDate(operation.createdAt)}`);
                 }
                 if (operation.status === 'COMPLETED' && operation.completedAt && operation.createdAt) {
                     this.log(`  Completed: ${formatDate(operation.completedAt)}`);

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

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/blueprints/init.js

@@ -0,0 +1,56 @@
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { Command } from '@oclif/core';
+import inquirer from 'inquirer';
+import { findBlueprintFile, writeBlueprintToDisk, writeConfigFile, } from '../../actions/blueprints/blueprint.js';
+import { listProjects } from '../../actions/blueprints/projects.js';
+export default class Init extends Command {
+    static description = 'Initialize a new Blueprint';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const existingBlueprint = findBlueprintFile(undefined);
+        if (existingBlueprint) {
+            this.error(`A blueprint file already exists: ${existingBlueprint.fileName}`);
+        }
+        const { blueprintExtension } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'blueprintExtension',
+                message: 'Choose a blueprint type:',
+                choices: [
+                    { name: 'JSON (Recommended)', value: 'json' },
+                    { name: 'JavaScript (Beta)', value: 'js' },
+                    { name: 'TypeScript (Alpha)', value: 'ts' },
+                ],
+                default: 'json',
+            },
+        ]);
+        const { ok, projects, error } = await listProjects();
+        if (!ok) {
+            this.error(error);
+        }
+        if (projects.length === 0) {
+            this.error('No projects found. Please create a project in Sanity.io first.');
+        }
+        const projectChoices = projects.map(({ displayName, id }) => ({
+            name: `${displayName} <${id}>`,
+            value: id,
+        }));
+        const { projectId } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'projectId',
+                message: 'Select your Sanity project:',
+                choices: projectChoices,
+            },
+        ]);
+        const fileName = `blueprint.${blueprintExtension}`;
+        const filePath = join(cwd(), fileName);
+        writeBlueprintToDisk({ path: filePath, fileType: blueprintExtension });
+        writeConfigFile({ projectId });
+        this.log(`Created new blueprint: ./${fileName}`);
+        if (blueprintExtension === 'ts') {
+            this.log('\nNote: TypeScript support requires "tsx" to be installed. Run: npm install -D tsx');
+        }
+    }
+}