@sanity/runtime-cli 13.0.3 → 13.2.0

package/dist/server/static/components/run-panel.js

@@ -23,6 +23,10 @@ class RunPanel extends ApiBaseElement {
   invoke = () => {
     const selectedEvent = this.api.store.selectedEvent
     const docFunction = this.api.store.selectedFunctionType === this.SANITY_FUNCTION_DOCUMENT
+    const mediaFunction =
+      this.api.store.selectedFunctionType === this.SANITY_FUNCTION_MEDIA_LIBRARY_ASSET
+    const scheduleFunction = this.api.store.selectedFunctionType === this.SANITY_FUNCTION_SCHEDULE
+    const docOrScheduleFunction = docFunction || scheduleFunction
 
     this.api.store.result = {logs: '', time: 0}
     let event = {}
@@ -53,12 +57,16 @@ class RunPanel extends ApiBaseElement {
         projectId: this.api.store.selectedProject,
         token: this.api.store.withToken,
       },
-      eventResourceType: docFunction ? 'dataset' : 'media-library',
-      eventResourceId: docFunction
+      eventResourceType: scheduleFunction
+        ? 'schedule'
+        : mediaFunction
+          ? 'media-library'
+          : 'dataset',
+      eventResourceId: docOrScheduleFunction
         ? `${this.api.store.selectedProject}.${this.api.store.selectedDataset}`
         : this.api.store.selectedMediaLibrary,
-      functionResourceType: 'project',
-      functionResourceId: docFunction
+      functionResourceType: docOrScheduleFunction ? 'project' : 'organization',
+      functionResourceId: docOrScheduleFunction
         ? this.api.store.selectedProject
         : this.api.store.selectedOrganization,
     }

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

@@ -5849,7 +5849,7 @@ class SelectionRange {
     Compare this range to another range.
     */
     eq(other, includeAssoc = false) {
-        return this.anchor == other.anchor && this.head == other.head &&
+        return this.anchor == other.anchor && this.head == other.head && this.goalColumn == other.goalColumn &&
             (!includeAssoc || !this.empty || this.assoc == other.assoc);
     }
     /**
@@ -7338,7 +7338,8 @@ class EditorState {
      - Other (anything else)
     */
     charCategorizer(at) {
-        return makeCategorizer(this.languageDataAt("wordChars", at).join(""));
+        let chars = this.languageDataAt("wordChars", at);
+        return makeCategorizer(chars.length ? chars[0] : "");
     }
     /**
     Find the word at the given position, meaning the range
@@ -7524,6 +7525,9 @@ class RangeValue {
 RangeValue.prototype.startSide = RangeValue.prototype.endSide = 0;
 RangeValue.prototype.point = false;
 RangeValue.prototype.mapMode = MapMode.TrackDel;
+function cmpVal(a, b) {
+    return a == b || a.constructor == b.constructor && a.eq(b);
+}
 /**
 A range associates a value with a range of positions.
 */
@@ -7830,7 +7834,7 @@ class RangeSet {
         for (;;) {
             if (sideA.to != sideB.to ||
                 !sameValues(sideA.active, sideB.active) ||
-                sideA.point && (!sideB.point || !sideA.point.eq(sideB.point)))
+                sideA.point && (!sideB.point || !cmpVal(sideA.point, sideB.point)))
                 return false;
             if (sideA.to > to)
                 return true;
@@ -8305,22 +8309,27 @@ function compare(a, startA, b, startB, length, comparator) {
     b.goto(startB);
     let endB = startB + length;
     let pos = startB, dPos = startB - startA;
-    for (;;) {
+    let bounds = !!comparator.boundChange;
+    for (let boundChange = false;;) {
         let dEnd = (a.to + dPos) - b.to, diff = dEnd || a.endSide - b.endSide;
         let end = diff < 0 ? a.to + dPos : b.to, clipEnd = Math.min(end, endB);
-        if (a.point || b.point) {
-            if (!(a.point && b.point && (a.point == b.point || a.point.eq(b.point)) &&
+        let point = a.point || b.point;
+        if (point) {
+            if (!(a.point && b.point && cmpVal(a.point, b.point) &&
                 sameValues(a.activeForPoint(a.to), b.activeForPoint(b.to))))
                 comparator.comparePoint(pos, clipEnd, a.point, b.point);
+            boundChange = false;
         }
         else {
+            if (boundChange)
+                comparator.boundChange(pos);
             if (clipEnd > pos && !sameValues(a.active, b.active))
                 comparator.compareRange(pos, clipEnd, a.active, b.active);
+            if (bounds && clipEnd < endB && (dEnd || a.openEnd(end) != b.openEnd(end)))
+                boundChange = true;
         }
         if (end > endB)
             break;
-        if ((dEnd || a.openEnd != b.openEnd) && comparator.boundChange)
-            comparator.boundChange(end);
         pos = end;
         if (diff <= 0)
             a.next();
@@ -8332,7 +8341,7 @@ function sameValues(a, b) {
     if (a.length != b.length)
         return false;
     for (let i = 0; i < a.length; i++)
-        if (a[i] != b[i] && !a[i].eq(b[i]))
+        if (a[i] != b[i] && !cmpVal(a[i], b[i]))
             return false;
     return true;
 }
@@ -27250,4 +27259,4 @@ function prettyMilliseconds(milliseconds, options) {
 	return sign + result.join(separator);
 }
 
-export { EditorState, EditorView, HighlightStyle, Store, basicSetup, json, prettyBytes, prettyMilliseconds, syntaxHighlighting, tags };
+export { Compartment, EditorState, EditorView, HighlightStyle, Store, basicSetup, json, prettyBytes, prettyMilliseconds, syntaxHighlighting, tags };

package/dist/utils/child-process-wrapper.js

@@ -2,6 +2,7 @@ import {table as renderTable} from 'node:console'
 import {existsSync, statSync} from 'node:fs'
 import {isAbsolute, join} from 'node:path'
 import process from 'node:process'
+import {pathToFileURL} from 'node:url'
 import {inspect} from 'node:util'
 
 export function getFunctionSource(src) {
@@ -12,9 +13,9 @@ export function getFunctionSource(src) {
     if (!existsSync(indexPath)) {
       throw Error(`Function directory ${pathToCheck} has no index.js`)
     }
-    return `file://${indexPath}`
+    return pathToFileURL(indexPath).href
   }
-  return `file://${pathToCheck}`
+  return pathToFileURL(pathToCheck).href
 }
 
 // Monkey patch console menthods to have logs match server log format

package/dist/utils/display/blueprints-formatting.d.ts

@@ -1,7 +1,7 @@
 import type { Blueprint, Resource } from '@sanity/blueprints-parser';
-import { type DeployedResource, type Stack } from '../types.js';
+import { type BlueprintResourceRecord, type Stack } from '../types.js';
 export declare function formatTitle(title: string, name: string): string;
-export declare function formatDeployedResourceTree(resources: DeployedResource[] | undefined, verbose?: boolean): string;
+export declare function formatDeployedResourceTree(resources: BlueprintResourceRecord[] | undefined, verbose?: boolean): string;
 export declare function formatResourceTree(resources: Resource[] | undefined, verbose?: boolean): string;
 export declare function formatStackInfo(stack: Stack | Blueprint, isCurrentStack?: boolean): string;
 export declare function formatStacksListing(stacks: Stack[], currentStackId?: string): string;

package/dist/utils/display/blueprints-formatting.js

@@ -1,10 +1,10 @@
 import { treeify } from 'array-treeify';
 import chalk from 'chalk';
-import { SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULE, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
-import { isCorsOriginResource, isDatasetResource, isRoleResource, isWebhookResource, } from '../types.js';
+import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULE, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
+import { isCorsOriginResource, isDatasetResource, isRobotResource, isRoleResource, isWebhookResource, } from '../types.js';
 import { formatDate, formatDuration } from './dates.js';
 import { niceId } from './presenters.js';
-import { arrayifyCors, arrayifyDataset, arrayifyFunction, arrayifyRole, arrayifyWebhook, } from './resources-formatting.js';
+import { arrayifyCors, arrayifyDataset, arrayifyFunction, arrayifyRobot, arrayifyRole, arrayifyWebhook, } from './resources-formatting.js';
 const functionCategory = {
     label: 'Functions',
     displayNameAttribute: 'displayName',
@@ -18,6 +18,13 @@ const RESOURCE_CATEGORIES = {
             return isRoleResource(res) ? arrayifyRole(res) : [];
         },
     },
+    [SANITY_ACCESS_ROBOT]: {
+        label: 'Robots',
+        displayNameAttribute: 'label',
+        formatDetails(res) {
+            return isRobotResource(res) ? arrayifyRobot(res) : [];
+        },
+    },
     [SANITY_FUNCTION_DOCUMENT]: functionCategory,
     [SANITY_FUNCTION_MEDIA_LIBRARY_ASSET]: functionCategory,
     [SANITY_FUNCTION_SCHEDULE]: functionCategory,

package/dist/utils/display/prompt.js

@@ -32,24 +32,25 @@ export async function promptForProject({ token, knownOrganizationId, knownProjec
     if (organizations.length > 1) {
         const orgChoices = organizations.map(({ organization, projects }) => ({
             name: `"${organization.name}" ${niceId(organization.id)}`,
-            value: { organization, projects },
+            value: organization.id,
             disabled: !projects || projects.length === 0 ? '(0 Projects)' : false,
         }));
-        const pickedOrganization = await select({
+        const pickedOrgId = await select({
             message: 'Which Organization would you like to use?',
             choices: orgChoices,
             default: knownOrganizationId,
         });
-        projects = pickedOrganization.projects;
+        const pickedOrg = organizations.find((o) => o.organization.id === pickedOrgId);
+        projects = pickedOrg?.projects;
     }
     else {
         projects = organizations[0].projects;
     }
     const projectChoices = projects.map(({ displayName, id: projectId }) => ({
         name: `"${displayName}" ${niceId(projectId)}`,
-        value: { projectId, displayName },
+        value: projectId,
     }));
-    let pickedProject;
+    let pickedProjectId;
     if (projectChoices.length === 1) {
         const onlyProject = projectChoices[0];
         const confirmed = await confirm({
@@ -57,18 +58,21 @@ export async function promptForProject({ token, knownOrganizationId, knownProjec
             default: true,
         });
         if (confirmed)
-            pickedProject = onlyProject.value;
+            pickedProjectId = onlyProject.value;
         else
             throw new Error('No project selected');
     }
     else {
-        pickedProject = await select({
+        pickedProjectId = await select({
             message: 'Choose a Sanity Project:',
             choices: projectChoices,
             default: knownProjectId,
         });
     }
-    return pickedProject;
+    const pickedProject = projects.find((p) => p.id === pickedProjectId);
+    if (!pickedProject)
+        throw new Error('Project not found');
+    return { projectId: pickedProject.id, displayName: pickedProject.displayName };
 }
 /**
  * Prompt the user for a Stack ID after selecting a Project.
@@ -83,24 +87,24 @@ export async function promptForStack({ projectId, token, logger, }) {
     if (!stacksOk) {
         throw new Error(stacksErr || 'Failed to list Stacks');
     }
-    const newStackValue = { id: 'new', name: 'new' };
-    let pickedStackId = newStackValue;
+    const NEW_STACK_ID = 'new';
+    let pickedStackId = NEW_STACK_ID;
     if (stacks.length > 0) {
         const stackChoices = [];
         stackChoices.push(new Separator(chalk.underline('Create a new Stack:')));
-        stackChoices.push({ name: chalk.bold('New Stack ✨'), value: newStackValue });
+        stackChoices.push({ name: chalk.bold('New Stack ✨'), value: NEW_STACK_ID });
         stackChoices.push(new 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: { id: s.id, name: s.name },
+            value: s.id,
         })));
         pickedStackId = await select({
             message: 'Select a deployment Stack:',
             choices: stackChoices,
-            default: newStackValue,
+            default: NEW_STACK_ID,
         });
     }
-    if (pickedStackId.id === 'new') {
+    if (pickedStackId === NEW_STACK_ID) {
         const stackName = await input({
             message: 'Enter a name for your new Stack:',
             validate: (input) => input.length > 0 || 'Stack name is required',
@@ -114,5 +118,8 @@ export async function promptForStack({ projectId, token, logger, }) {
         });
         return { stackId: stack.id, name: stackName };
     }
-    return { stackId: pickedStackId.id, name: pickedStackId.name };
+    const pickedStack = stacks.find((s) => s.id === pickedStackId);
+    if (!pickedStack)
+        throw new Error('Stack not found');
+    return { stackId: pickedStack.id, name: pickedStack.name };
 }

package/dist/utils/display/resources-formatting.d.ts

@@ -1,8 +1,9 @@
-import type { BlueprintCorsOriginResource, BlueprintDatasetResource, BlueprintDocumentWebhookResource, BlueprintRoleResource } from '@sanity/blueprints';
+import type { BlueprintCorsOriginResource, BlueprintDatasetResource, BlueprintDocumentWebhookResource, BlueprintRobotResource, BlueprintRoleResource } from '@sanity/blueprints';
 import type { TreeInput } from 'array-treeify';
 import { type FunctionResourceBase } from '../../utils/types.js';
 export declare function arrayifyFunction(fn: FunctionResourceBase): TreeInput;
 export declare function arrayifyCors(resource: BlueprintCorsOriginResource): TreeInput;
+export declare function arrayifyRobot(resource: BlueprintRobotResource): TreeInput;
 export declare function arrayifyRole(resource: BlueprintRoleResource): TreeInput;
 export declare function arrayifyDataset(resource: BlueprintDatasetResource): TreeInput;
 export declare function arrayifyWebhook(resource: BlueprintDocumentWebhookResource): TreeInput;

package/dist/utils/display/resources-formatting.js

@@ -49,6 +49,37 @@ export function arrayifyFunction(fn) {
 export function arrayifyCors(resource) {
     return [formatLabeledValue('origin', resource.origin)];
 }
+export function arrayifyRobot(resource) {
+    const details = [formatLabeledValue('label', resource.label)];
+    if (resource.memberships.length > 0) {
+        details.push(formatLabel('memberships'));
+        const memberships = [];
+        resource.memberships.forEach((m, i) => {
+            const membership = [];
+            membership.push(formatLabeledValue('resourceType', m.resourceType));
+            membership.push(formatLabeledValue('resourceId', m.resourceId));
+            if (m.roleNames.length > 0) {
+                membership.push(formatLabeledValue('roleNames', m.roleNames.join(', ')));
+            }
+            else {
+                membership.push(formatLabeledValue('roleNames', '[]'));
+            }
+            memberships.push(formatLabel(i.toString()));
+            memberships.push(membership);
+        });
+        details.push(memberships);
+    }
+    else {
+        details.push(formatLabeledValue('memberships', '[]'));
+    }
+    if (resource.resourceType) {
+        details.push(formatLabeledValue('resourceType', resource.resourceType));
+    }
+    if (resource.resourceId) {
+        details.push(formatLabeledValue('resourceId', resource.resourceId));
+    }
+    return details;
+}
 export function arrayifyRole(resource) {
     const details = [];
     if (resource.description)

package/dist/utils/find-function.js

@@ -13,7 +13,12 @@ export function findFunctionInBlueprint(blueprint, name) {
 export function findFunctionInStack(stack, name) {
     const func = stack?.resources?.find((r) => r?.type?.startsWith('sanity.function.') && r.name === name);
     if (!func)
-        throw Error(`Unable to find function ${name}`);
+        throw Error(`Unable to find function: "${name}"`);
+    if (!isDeployedResource(func))
+        throw Error(`Unable to find deployed function: "${name}"`);
     // return the deployed resource
     return func;
 }
+function isDeployedResource(r) {
+    return 'externalId' in r && typeof r.externalId === 'string';
+}

package/dist/utils/functions/resource-to-arc.js

@@ -1,7 +1,16 @@
-import { sep } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { resolve, sep } from 'node:path';
+import { cwd } from 'node:process';
 export async function convertResourceToArcFormat(resource, transpiled) {
+    if (!resource.src) {
+        throw Error('Missing `resource.src` property');
+    }
+    // Get stats from file
+    const stats = await stat(resolve(cwd(), resource.src));
+    // Convert resource.src to arc file path format
     const srcPath = resource.src?.split(sep).join('/');
-    const functionPath = transpiled ? `${srcPath}/.build/function-${resource.name}` : srcPath;
+    const entryDir = stats.isFile() ? srcPath.substring(0, srcPath.lastIndexOf('/')) : srcPath;
+    const functionPath = transpiled ? `${entryDir}/.build/function-${resource.name}` : entryDir;
     return `@app
 hydrate-function
 

package/dist/utils/types.d.ts

@@ -1,4 +1,4 @@
-import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentWebhookResource, type BlueprintResource, type BlueprintRoleResource } from '@sanity/blueprints';
+import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentWebhookResource, type BlueprintResource, type BlueprintRobotResource, type BlueprintRoleResource } from '@sanity/blueprints';
 import type { Blueprint } from '@sanity/blueprints-parser';
 import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULE } from '../constants.js';
 export type ScopeType = 'organization' | 'project';
@@ -48,11 +48,16 @@ interface FunctionResourceScheduleExpressionEvent {
     expression: string;
 }
 type FunctionResourceScheduleEvent = FunctionResourceScheduleExplicitEvent | FunctionResourceScheduleExpressionEvent;
-export interface DeployedResource extends BlueprintResource {
+/** The Blueprint resource as represented in the Blueprints API database */
+export interface BlueprintResourceRecord extends BlueprintResource {
     id: string;
-    externalId: string;
+    externalId?: string | null;
     parameters: Record<string, unknown>;
 }
+/** The deployed resource; complete with external ID */
+export interface DeployedResource extends BlueprintResourceRecord {
+    externalId: string;
+}
 export declare function isLocalFunctionResource(r: BlueprintResource): r is FunctionResourceBase;
 export declare function isDocumentFunctionResource<T extends BlueprintResource>(r: T): r is T & FunctionResourceDocument;
 export declare function isMediaLibraryAssetFunctionResource<T extends BlueprintResource>(r: T): r is T & FunctionResourceMediaLibraryAsset;
@@ -60,6 +65,7 @@ export declare function isScheduleFunctionResource<T extends BlueprintResource>(
 export declare function isLocalFunctionCollection<T extends BlueprintResource>(r: T): r is T & FunctionsCollection;
 export declare function isScheduleEvent(e: unknown): e is FunctionResourceScheduleEvent;
 export declare function isCorsOriginResource(r: unknown): r is BlueprintCorsOriginResource;
+export declare function isRobotResource(r: unknown): r is BlueprintRobotResource;
 export declare function isRoleResource(r: unknown): r is BlueprintRoleResource;
 export declare function isDatasetResource(r: unknown): r is BlueprintDatasetResource;
 export declare function isWebhookResource(r: unknown): r is BlueprintDocumentWebhookResource;
@@ -114,7 +120,7 @@ export interface Stack {
     displayName: string;
     scopeType: ScopeType;
     scopeId: string;
-    resources: Array<DeployedResource>;
+    resources: Array<BlueprintResourceRecord>;
     createdAt?: string;
     updatedAt?: string;
     recentOperation?: StackOperation;

package/dist/utils/types.js

@@ -1,4 +1,4 @@
-import { validateCorsOrigin, validateDataset, validateDocumentWebhook, validateRole, } from '@sanity/blueprints';
+import { validateCorsOrigin, validateDataset, validateDocumentWebhook, validateRobot, validateRole, } from '@sanity/blueprints';
 import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULE, } from '../constants.js';
 // type narrowing with predicate functions
 export function isLocalFunctionResource(r) {
@@ -22,6 +22,9 @@ export function isScheduleEvent(e) {
 export function isCorsOriginResource(r) {
     return validateCorsOrigin(r).length === 0;
 }
+export function isRobotResource(r) {
+    return validateRobot(r).length === 0;
+}
 export function isRoleResource(r) {
     return validateRole(r).length === 0;
 }

package/dist/utils/validate/index.d.ts

@@ -1 +1,4 @@
+import type { Resource } from '@sanity/blueprints-parser';
+import type { BlueprintParserError } from '../types.js';
 export * as validate from './resource.js';
+export declare function validateResources(resources: Resource[]): BlueprintParserError[];

package/dist/utils/validate/index.js

@@ -1 +1,36 @@
+import { validateCorsOrigin, validateDataset, validateDocumentFunction, validateDocumentWebhook, validateMediaLibraryAssetFunction, validateRole, validateScheduleFunction, } from '@sanity/blueprints';
+import { SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULE, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
 export * as validate from './resource.js';
+const RESOURCE_VALIDATORS = {
+    [SANITY_ACCESS_ROLE]: {
+        validate: validateRole,
+    },
+    [SANITY_FUNCTION_DOCUMENT]: {
+        validate: validateDocumentFunction,
+    },
+    [SANITY_FUNCTION_MEDIA_LIBRARY_ASSET]: {
+        validate: validateMediaLibraryAssetFunction,
+    },
+    [SANITY_FUNCTION_SCHEDULE]: {
+        validate: validateScheduleFunction,
+    },
+    [SANITY_PROJECT_CORS]: {
+        validate: validateCorsOrigin,
+    },
+    [SANITY_PROJECT_DATASET]: {
+        validate: validateDataset,
+    },
+    [SANITY_PROJECT_WEBHOOK]: {
+        validate: validateDocumentWebhook,
+    },
+};
+export function validateResources(resources) {
+    const errors = [];
+    for (const resource of resources) {
+        const validator = RESOURCE_VALIDATORS[resource.type];
+        if (validator) {
+            errors.push(...validator.validate(resource));
+        }
+    }
+    return errors;
+}