@sanity/runtime-cli 10.11.2 → 11.0.2

package/dist/cores/blueprints/stacks.js

@@ -1,24 +1,39 @@
 import chalk from 'chalk';
 import { listStacks } from '../../actions/blueprints/stacks.js';
 import { formatStacksListing } from '../../utils/display/blueprints-formatting.js';
-import { niceId } from '../../utils/display/presenters.js';
+import { capitalize, niceId } from '../../utils/display/presenters.js';
 export async function blueprintStacksCore(options) {
     const { log, token, blueprint, flags } = options;
-    const { projectId: blueprintProjectId, stackId: blueprintStackId } = blueprint;
-    const projectId = flags['project-id'] || blueprintProjectId;
-    if (!projectId) {
+    const { scopeType: blueprintScopeType, scopeId: blueprintScopeId, stackId: blueprintStackId, } = blueprint;
+    const flagProjectId = flags['project-id'];
+    const flagOrganizationId = flags['organization-id'];
+    if (flagOrganizationId && flagProjectId) {
+        log('Cannot specify both --organization-id and --project-id');
+        return { success: false, error: 'Cannot specify both --organization-id and --project-id' };
+    }
+    let scopeType = blueprintScopeType;
+    let scopeId = blueprintScopeId;
+    if (flagOrganizationId) {
+        scopeType = 'organization';
+        scopeId = flagOrganizationId;
+    }
+    if (flagProjectId) {
+        scopeType = 'project';
+        scopeId = flagProjectId;
+    }
+    if (!scopeType || !scopeId) {
         log('Run in a Blueprint directory or provide a Project with --project-id');
-        return { success: false, error: 'No Project ID provided' };
+        return { success: false, error: 'Unable to determine scope for Blueprint Stacks' };
     }
     try {
-        const { ok, stacks, error } = await listStacks({ token, scopeType: 'project', scopeId: projectId });
+        const { ok, stacks, error } = await listStacks({ token, scopeType, scopeId });
         if (!ok)
             return { success: false, error: error || 'Failed to list stacks' };
         if (!stacks || stacks.length === 0) {
             log('No stacks found');
             return { success: true };
         }
-        log(`${chalk.bold('Project')} ${niceId(projectId)} ${chalk.bold('Stacks')}:\n`);
+        log(`${chalk.bold(capitalize(scopeType))} ${niceId(scopeId)} ${chalk.bold('Stacks')}:\n`);
         log(formatStacksListing(stacks, blueprintStackId));
         return { success: true };
     }

package/dist/cores/{blueprints → functions}/add.d.ts

@@ -1,19 +1,16 @@
 import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
 import type { CoreConfig, CoreResult } from '../index.js';
-export interface BlueprintAddOptions extends CoreConfig {
+export interface FunctionAddOptions extends CoreConfig {
     blueprint: ReadBlueprintResult;
-    args: {
-        type: string;
-    };
     flags: {
         example?: string;
         name?: string;
-        'fn-type'?: string | string[];
+        type?: string | string[];
         language?: string;
         javascript?: boolean;
-        'fn-helpers'?: boolean;
-        'fn-installer'?: string;
+        helpers?: boolean;
+        installer?: string;
         install?: boolean;
     };
 }
-export declare function blueprintAddCore(options: BlueprintAddOptions): Promise<CoreResult>;
+export declare function functionAddCore(options: FunctionAddOptions): Promise<CoreResult>;

package/dist/cores/{blueprints → functions}/add.js

@@ -16,31 +16,20 @@ const generateFunctionBlueprintResourceTemplate = (fnName, eventNames) => `
     ],
   })
 `;
-export async function blueprintAddCore(options) {
+export async function functionAddCore(options) {
     const root = cwd();
-    const { log, blueprint, args, flags } = options;
+    const { log, blueprint, flags } = options;
     const { blueprintFilePath } = blueprint.fileInfo;
-    const { type: resourceType } = args;
-    const { example: flagExample, name: flagResourceName, 'fn-type': flagFnType, javascript: flagJs, 'fn-helpers': flagFnHelpers, install: flagI, 'fn-installer': flagFnInstaller, // can be 'skip'!
-     } = flags;
-    let { language: flagFnLang } = flags;
-    flagFnLang = flagJs ? 'js' : flagFnLang;
-    if (resourceType !== 'function') {
-        return {
-            success: false,
-            error: `Unsupported Resource type: ${resourceType}`,
-        };
-    }
+    const { example: flagExample, name: flagResourceName, type: flagType, javascript: flagJs, helpers: flagHelpers, install: flagI, installer: flagInstaller, } = flags;
+    let { language: flagLang } = flags;
+    flagLang = flagJs ? 'js' : flagLang;
     if (flagExample) {
-        // ! short circuit for examples
-        log(warn(`Example feature is experimental. Setting up "${flagExample}"...`)); // we need to...
-        // * 1. verify example exists in the recipes repo
+        // short circuit whole command for example flag
+        log(`Setting up "${flagExample}"...`);
         const exampleExists = await verifyExampleExists({ type: 'function', name: flagExample });
         if (!exampleExists) {
             return { success: false, error: `Function example "${flagExample}" does not exist.` };
         }
-        // * 2. download and write example to disk
-        // TODO: revisit path string handling; differs for fs operations vs. display
         const exampleDir = join(dirname(blueprintFilePath), 'functions', flagExample);
         if (existsSync(exampleDir)) {
             return {
@@ -61,7 +50,6 @@ export async function blueprintAddCore(options) {
         for (const filePath of Object.keys(files)) {
             log(check(`${chalk.bold('Created:')}  ${newDir}/${filePath}`));
         }
-        // * 3. print instructions
         if (functionConfig) {
             log('');
             log(chalk.bold(`Add the following to ${blueprint.fileInfo.fileName}:`));
@@ -70,7 +58,6 @@ export async function blueprintAddCore(options) {
                 log(indent(highlight(configString)));
             }
             else {
-                // modify configString so it doesn't have quoted keys
                 const objectLiteral = configString.replace(/^(\s*)"([a-zA-Z_$][a-zA-Z0-9_$]*)":/gm, '$1$2:');
                 log(indent(highlight(`defineDocumentFunction(${objectLiteral})`)));
             }
@@ -85,29 +72,27 @@ export async function blueprintAddCore(options) {
         return { success: true };
     }
     if (flagI) {
-        if (flagFnInstaller) {
+        if (flagInstaller) {
             return {
                 success: false,
-                error: 'Cannot use --fn-installer flag with the --install flag',
+                error: 'Cannot use --installer flag with the --install flag',
             };
         }
-        if (!flagFnHelpers) {
+        if (!flagHelpers) {
             return {
                 success: false,
-                error: 'Cannot use --no-fn-helpers flag with the --install flag',
+                error: 'Cannot use --no-helpers flag with the --install flag',
             };
         }
     }
     if (flagResourceName && !validateFunctionName(flagResourceName)) {
-        // if provided && invalid, return error ASAP
         return {
             success: false,
-            error: `Invalid function name: ${flagResourceName}`,
+            error: `Invalid function name: "${chalk.bold(flagResourceName)}"`,
         };
     }
     try {
         const fnName = flagResourceName || (await promptForFunctionName());
-        // look for existing function with same name
         if (blueprint.parsedBlueprint.resources?.some((r) => r.name === fnName)) {
             return {
                 success: false,
@@ -115,18 +100,18 @@ export async function blueprintAddCore(options) {
             };
         }
         let fnTypes;
-        if (flagFnType) {
-            if (Array.isArray(flagFnType)) {
-                fnTypes = flagFnType;
+        if (flagType) {
+            if (Array.isArray(flagType)) {
+                fnTypes = flagType;
             }
             else {
-                fnTypes = [flagFnType];
+                fnTypes = [flagType];
             }
         }
         else {
             fnTypes = await promptForFunctionType();
         }
-        const fnLang = flagFnLang || (await promptForFunctionLang());
+        const fnLang = flagLang || (await promptForFunctionLang());
         if (fnTypes.length === 0) {
             throw new Error('At least one function type must be provided.');
         }
@@ -136,27 +121,23 @@ export async function blueprintAddCore(options) {
         let addHelpers;
         let installCommand;
         if (!['ts', 'js'].includes(fnLang)) {
-            // language is not supported
             addHelpers = false;
             installCommand = null;
         }
-        else if (flagFnHelpers === false) {
-            // explicit "false" means user does not want helpers: "--no-fn-helpers"
+        else if (flagHelpers === false) {
             addHelpers = false;
             installCommand = null;
         }
         else if (flagI) {
-            // user wants to install helpers with npm
             addHelpers = true;
             installCommand = 'npm';
         }
-        else if (flagFnInstaller) {
-            addHelpers = true; //  if installer is passed, assume addHelpers
-            installCommand = flagFnInstaller === 'skip' ? null : flagFnInstaller;
+        else if (flagInstaller) {
+            addHelpers = true;
+            installCommand = flagInstaller === 'skip' ? null : flagInstaller;
         }
         else {
-            // unsure; ask...
-            addHelpers = flagFnHelpers || (await promptForAddHelpers());
+            addHelpers = flagHelpers || (await promptForAddHelpers());
             installCommand = addHelpers ? await promptForInstallCommand() : null;
         }
         if (installCommand)
@@ -171,7 +152,6 @@ export async function blueprintAddCore(options) {
         });
         log(`\nCreated function: ${filePath.replace(root, '')}`);
         if (!resourceAdded) {
-            // print the resource definition for manual addition
             log(`\n${chalk.bold('Add the Resource to your Blueprint:')}`);
             switch (blueprint.fileInfo.extension) {
                 case '.ts':
@@ -186,7 +166,6 @@ export async function blueprintAddCore(options) {
             }
         }
         else {
-            // added to blueprint.json
             log(`Function "${chalk.bold(fnName)}" added to Blueprint file.`);
         }
         return { success: true };

package/dist/cores/functions/index.d.ts

@@ -1,3 +1,5 @@
+export type { FunctionAddOptions } from './add.js';
+export { functionAddCore } from './add.js';
 export type { FunctionDevOptions } from './dev.js';
 export { functionDevCore } from './dev.js';
 export type { FunctionEnvAddOptions as EnvAddOptions } from './env/add.js';

package/dist/cores/functions/index.js

@@ -1,3 +1,4 @@
+export { functionAddCore } from './add.js';
 export { functionDevCore } from './dev.js';
 export { functionEnvAddCore } from './env/add.js';
 export { functionEnvListCore } from './env/list.js';

package/dist/cores/functions/test.d.ts

@@ -13,6 +13,7 @@ export interface FunctionTestOptions extends CoreConfig {
         api?: string;
         dataset?: string;
         'project-id'?: string;
+        'organization-id'?: string;
         'document-id'?: string;
         'with-user-token'?: boolean;
         'data-before'?: string;

package/dist/cores/functions/test.js

@@ -13,11 +13,8 @@ export async function functionTestCore(options) {
     const { blueprint, log, args, flags } = options;
     const { name: fnName } = args;
     const { data, event, file, timeout, api, dataset, 'document-id': documentId, 'with-user-token': withUserToken, 'data-before': dataBefore, 'data-after': dataAfter, 'file-before': fileBefore, 'file-after': fileAfter, 'document-id-before': documentIdBefore, 'document-id-after': documentIdAfter, } = flags;
-    let { 'project-id': projectId } = flags;
     const { parsedBlueprint } = blueprint;
-    if (!projectId && blueprint?.projectId) {
-        projectId = blueprint.projectId;
-    }
+    const { 'project-id': projectId = blueprint?.projectId, 'organization-id': organizationId = blueprint?.organizationId, } = flags;
     let eventType;
     if (!event) {
         eventType = 'create';
@@ -38,6 +35,7 @@ export async function functionTestCore(options) {
                 apiVersion: api,
                 dataset,
                 projectId,
+                organizationId,
             },
         };
         // If the user sets the flag to use the real token set it in our options

package/dist/cores/index.d.ts

@@ -1,5 +1,5 @@
 import { type ReadBlueprintResult } from '../actions/blueprints/blueprint.js';
-import type { AuthParams, Result, Stack } from '../utils/types.js';
+import type { AuthParams, Result, ScopeType, Stack } from '../utils/types.js';
 export * as blueprintsCores from './blueprints/index.js';
 export * as functionsCores from './functions/index.js';
 export interface CoreConfig {
@@ -14,7 +14,8 @@ export interface BlueprintConfig extends CoreConfig {
 }
 export interface DeployedBlueprintConfig extends BlueprintConfig {
     stackId: string;
-    projectId: string;
+    scopeType: ScopeType;
+    scopeId: string;
     auth: AuthParams;
     deployedStack: Stack;
 }

package/dist/cores/index.js

@@ -40,19 +40,19 @@ export async function initDeployedBlueprintConfig(config) {
         config.blueprint = blueprintResult.value.blueprint;
         config.token = blueprintResult.value.token;
     }
-    const { projectId, stackId } = config.blueprint;
-    if (!(projectId && stackId)) {
-        config.log(`Run \`${config.bin} blueprints config --edit --test\` to update your config`);
-        if (!projectId)
-            return { ok: false, error: 'Missing Project configuration for Blueprint' };
+    const { scopeType, scopeId, stackId } = config.blueprint;
+    if (!(scopeType && scopeId && stackId)) {
+        config.log(`Incomplete configuration. Run \`${config.bin} blueprints doctor\` for diagnostics.`);
+        if (!scopeType || !scopeId)
+            return { ok: false, error: 'Missing scope configuration for Blueprint' };
         if (!stackId)
             return { ok: false, error: 'Missing deployment configuration for Blueprint' };
     }
-    const auth = { token: config.token, scopeType: 'project', scopeId: projectId };
+    const auth = { token: config.token, scopeType, scopeId };
     const stackResponse = await getStack({ stackId, auth });
     if (!stackResponse.ok) {
         config.log(`Could not retrieve deployment info for ${niceId(stackId)}. Was it destroyed?`);
-        config.log(`Run \`${config.bin} blueprints config --edit --test\` to update your config`);
+        config.log(`Run \`${config.bin} blueprints doctor\` for diagnostics.`);
         return { ok: false, error: 'Missing deployment' };
     }
     return {
@@ -62,7 +62,8 @@ export async function initDeployedBlueprintConfig(config) {
             log: config.log,
             blueprint: config.blueprint,
             token: config.token,
-            projectId,
+            scopeType,
+            scopeId,
             stackId,
             auth,
             deployedStack: stackResponse.stack,

package/dist/server/static/index.html

@@ -39,7 +39,7 @@
         <main id="main-content" style='max-height: 100%; overflow: hidden;'>
               <payload-panel></payload-panel>
               <div>
-                <rule-panel></rule-paneL>
+                <rule-panel></rule-panel>
                 <response-panel></response-panel>
               </div>
               <console-panel></console-panel>

package/dist/server/static/vendor/vendor.bundle.js

@@ -24,6 +24,7 @@ class NodeProp {
         this.deserialize = config.deserialize || (() => {
             throw new Error("This node type doesn't define a deserialize function");
         });
+        this.combine = config.combine || null;
     }
     /**
     This is meant to be used with
@@ -288,7 +289,10 @@ class NodeSet {
                 if (add) {
                     if (!newProps)
                         newProps = Object.assign({}, type.props);
-                    newProps[add[0].id] = add[1];
+                    let value = add[1], prop = add[0];
+                    if (prop.combine && prop.id in newProps)
+                        value = prop.combine(newProps[prop.id], value);
+                    newProps[prop.id] = value;
                 }
             }
             newTypes.push(newProps ? new NodeType(type.name, newProps, type.id, type.flags) : type);
@@ -1271,7 +1275,7 @@ function buildTree(data) {
     function takeNode(parentStart, minPos, children, positions, inRepeat, depth) {
         let { id, start, end, size } = cursor;
         let lookAheadAtStart = lookAhead, contextAtStart = contextHash;
-        while (size < 0) {
+        if (size < 0) {
             cursor.next();
             if (size == -1 /* SpecialRecord.Reuse */) {
                 let node = reused[id];
@@ -3663,7 +3667,7 @@ must be quoted as JSON strings.
 For example:
 
 ```javascript
-parser.withProps(
+parser.configure({props: [
   styleTags({
     // Style Number and BigNumber nodes
     "Number BigNumber": tags.number,
@@ -3678,7 +3682,7 @@ parser.withProps(
     // Style the node named "/" as punctuation
     '"/"': tags.punctuation
   })
-)
+]})
 ```
 */
 function styleTags(spec) {
@@ -3720,7 +3724,28 @@ function styleTags(spec) {
     }
     return ruleNodeProp.add(byName);
 }
-const ruleNodeProp = new NodeProp();
+const ruleNodeProp = new NodeProp({
+    combine(a, b) {
+        let cur, root, take;
+        while (a || b) {
+            if (!a || a.depth > b.depth) {
+                take = b;
+                b = b.next;
+            }
+            else {
+                take = a;
+                a = a.next;
+            }
+            let copy = new Rule(take.tags, take.mode, take.context);
+            if (cur)
+                cur.next = copy;
+            else
+                root = copy;
+            cur = copy;
+        }
+        return root;
+    }
+});
 class Rule {
     constructor(tags, mode, context, next) {
         this.tags = tags;

package/dist/utils/display/errors.js

@@ -10,8 +10,11 @@ export function presentBlueprintIssues(issues) {
             case 'NO_STACK_ID':
                 report.push('Existing deployment not found.');
                 break;
-            case 'NO_PROJECT_ID':
-                report.push('Project ID not found.');
+            case 'NO_SCOPE_TYPE':
+                report.push('Scope type not found.');
+                break;
+            case 'NO_SCOPE_ID':
+                report.push('Scope ID not found.');
                 break;
             case 'NO_STACK':
                 report.push('Existing deployment not found.');

package/dist/utils/display/presenters.d.ts

@@ -4,3 +4,4 @@ export declare function warn(str: string): string;
 export declare function severe(str: string): string;
 export declare function niceId(id: string | undefined): string;
 export declare function indent(str: string, spaces?: number): string;
+export declare function capitalize(str: string): string;

package/dist/utils/display/presenters.js

@@ -23,3 +23,6 @@ export function indent(str, spaces = 2) {
         .map((line) => (line.length > 0 ? pad + line : line))
         .join('\n');
 }
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/utils/types.d.ts

@@ -99,6 +99,7 @@ export interface InvokeContextOptions {
         apiVersion?: string;
         dataset?: string;
         projectId?: string;
+        organizationId?: string;
         token?: string;
     };
 }