@sanity/runtime-cli 12.1.0 → 12.2.0

package/dist/utils/invoke-local.js

@@ -11,6 +11,7 @@ import { resolveResourceDependencies } from './functions/resolve-dependencies.js
 import { shouldAutoResolveDependencies } from './functions/should-auto-resolve-deps.js';
 import { shouldTranspileFunction } from './functions/should-transpile.js';
 import { transpileFunction } from './transpile/transpile-function.js';
+import { isDocumentFunctionResource, isGroqContextOptions, isMediaLibraryAssetFunctionResource, } from './types.js';
 function getChildProcessWrapperPath() {
     return fileURLToPath(new URL('./child-process-wrapper.js', import.meta.url));
 }
@@ -34,7 +35,8 @@ function getEvent(rule) {
         projection: rule.projection || DEFAULT_GROQ_RULE.projection,
     };
 }
-export async function applyGroqRule(resource, data, before, after, projectId, dataset) {
+export async function applyGroqRule(resource, payload, projectId, dataset) {
+    const { before, after, payload: data = null } = payload;
     // If there is no rule set return everything
     if (!resource.event)
         return data;
@@ -64,17 +66,6 @@ export default async function invoke(resource, payload, context, options) {
     if (!resource.src) {
         throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
     }
-    const { before, after, payload: data = null } = payload;
-    const { forceColor = true, timeout = 10 } = options;
-    const { projectId, dataset } = context.clientOptions;
-    const filteredData = await applyGroqRule(resource, data, before, after, projectId, dataset);
-    if (typeof filteredData === 'undefined') {
-        return {
-            logs: `⚠️ Filter "${resource.event?.filter}" returned an empty result. Skipping invoke.`,
-            error: undefined,
-            json: undefined,
-        };
-    }
     let cleanupBundle = async () => { };
     let functionPath = '';
     let bundleTimings;
@@ -98,6 +89,24 @@ export default async function invoke(resource, payload, context, options) {
     if (!existingPackageJson) {
         createTempPackageJson(functionPath);
     }
+    const { forceColor = true, timeout = 10 } = options;
+    let filteredData = {};
+    if (isDocumentFunctionResource(resource) || isMediaLibraryAssetFunctionResource(resource)) {
+        if (!isGroqContextOptions(context)) {
+            throw new Error('GROQ-based functions require a context with clientOptions');
+        }
+        const { projectId, dataset } = context.clientOptions;
+        if ('before' in payload) {
+            filteredData = await applyGroqRule(resource, payload, projectId, dataset);
+            if (typeof filteredData === 'undefined') {
+                return {
+                    logs: `⚠️ Filter "${resource.event?.filter}" returned an empty result. Skipping invoke.`,
+                    error: undefined,
+                    json: undefined,
+                };
+            }
+        }
+    }
     return new Promise((resolve, reject) => {
         let child;
         let timer;
@@ -167,10 +176,12 @@ export default async function invoke(resource, payload, context, options) {
                 context: {
                     ...context,
                     local: true,
-                    clientOptions: {
-                        ...context.clientOptions,
-                        apiHost: config.apiUrl,
-                    },
+                    ...(isGroqContextOptions(context) && {
+                        clientOptions: {
+                            ...context.clientOptions,
+                            apiHost: config.apiUrl,
+                        },
+                    }),
                 },
             };
             child.send(JSON.stringify({ srcPath: functionPath, payload }, null, 2));

package/dist/utils/types.d.ts

@@ -1,4 +1,6 @@
+import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentWebhookResource, type BlueprintResource, 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';
 /** Result utility type */
 export type Result<T, E = string> = {
@@ -35,45 +37,58 @@ interface GroqRuleMediaLibraryFunction extends GroqRuleBase {
         id: string;
     };
 }
-/** @internal */
-export interface Resource {
-    name: string;
-    type: string;
-    id?: string;
-    externalId?: string;
-    displayName?: string;
+export interface FunctionResourceScheduleExplicitEvent {
+    minute: string;
+    hour: string;
+    dayOfMonth: string;
+    month: string;
+    dayOfWeek: string;
+}
+interface FunctionResourceScheduleExpressionEvent {
+    expression: string;
 }
-export interface DeployedResource extends Resource {
+type FunctionResourceScheduleEvent = FunctionResourceScheduleExplicitEvent | FunctionResourceScheduleExpressionEvent;
+export interface DeployedResource extends BlueprintResource {
     id: string;
     externalId: string;
+    parameters: Record<string, unknown>;
 }
-export declare function isLocalFunctionResource<T extends Resource>(r: T): r is T & FunctionResourceBase;
-export declare function isDocumentFunctionResource<T extends Resource>(r: T): r is T & FunctionResourceDocument;
-export declare function isMediaLibraryAssetFunctionResource<T extends Resource>(r: T): r is T & FunctionResourceMediaLibraryAsset;
-export declare function isLocalFunctionCollection<T extends Resource>(r: T): r is T & {
+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;
+export declare function isScheduleFunctionResource<T extends BlueprintResource>(r: T): r is T & FunctionResourceSchedule;
+export declare function isLocalFunctionCollection<T extends BlueprintResource>(r: T): r is T & {
     functions: Array<FunctionResourceBase>;
 };
-/** @internal */
-export type FunctionResource = FunctionResourceDocument | FunctionResourceMediaLibraryAsset | FunctionResourceBase;
-export interface FunctionResourceBase extends Resource {
+export declare function isScheduleEvent(e: unknown): e is FunctionResourceScheduleEvent;
+export declare function isCorsOriginResource(r: unknown): r is BlueprintCorsOriginResource;
+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;
+/** @internal */
+export type FunctionResource = FunctionResourceDocument | FunctionResourceMediaLibraryAsset | FunctionResourceSchedule | FunctionResourceBase;
+export type FunctionGroqResource = FunctionResourceDocument | FunctionResourceMediaLibraryAsset;
+export interface FunctionResourceBase extends BlueprintResource {
+    displayName?: string;
     src?: string;
     autoResolveDeps?: boolean;
     transpile?: boolean;
     memory?: number;
     timeout?: number;
     env?: Record<string, string>;
-    event?: GroqRuleBase;
+    event?: GroqRuleBase | FunctionResourceScheduleEvent;
 }
 interface FunctionResourceDocument extends FunctionResourceBase {
-    type: 'sanity.function.document';
+    type: typeof SANITY_FUNCTION_DOCUMENT;
     event?: GroqRuleDocumentFunction;
 }
 interface FunctionResourceMediaLibraryAsset extends FunctionResourceBase {
-    type: 'sanity.function.media-library.asset';
+    type: typeof SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
     event: GroqRuleMediaLibraryFunction;
 }
-export interface CorsResource extends Resource {
-    origin?: string;
+interface FunctionResourceSchedule extends FunctionResourceBase {
+    type: typeof SANITY_FUNCTION_SCHEDULE;
+    event: FunctionResourceScheduleEvent;
 }
 export interface Stack {
     id: string;
@@ -107,16 +122,22 @@ export interface BuildPayloadOptions {
     timeout?: number;
 }
 /** @internal */
-export interface InvokePayloadOptions {
+export interface InvokeGroqPayloadOptions {
     payload?: Record<string, unknown>;
     event: EventType;
     before: Record<string, unknown> | null;
     after: Record<string, unknown> | null;
 }
+export interface InvokeSchedulePayloadOptions {
+    payload?: Record<string, unknown>;
+    event: 'schedule';
+}
+export type InvokePayloadOptions = InvokeGroqPayloadOptions | InvokeSchedulePayloadOptions;
+export type InvokePayloadMetadata = Pick<InvokeGroqPayloadOptions, 'event' | 'before' | 'after'> | Pick<InvokeSchedulePayloadOptions, 'event'>;
 export type EventType = 'create' | 'update' | 'delete';
 export declare function isEventType(arg: string): arg is EventType;
 /** @internal */
-export interface InvokeContextOptions {
+export interface InvokeGroqContextOptions {
     clientOptions: {
         apiVersion?: string;
         dataset?: string;
@@ -133,6 +154,9 @@ export interface InvokeContextOptions {
     /** The resource ID of the function container; resource ID that houses the function. */
     functionResourceId: string;
 }
+export type InvokeScheduleContextOptions = Record<string, never>;
+export type InvokeContextOptions = InvokeGroqContextOptions | InvokeScheduleContextOptions;
+export declare function isGroqContextOptions(context: InvokeContextOptions): context is InvokeGroqContextOptions;
 /** @internal */
 export interface InvokeExecutionOptions {
     forceColor?: boolean;

package/dist/utils/types.js

@@ -1,19 +1,42 @@
+import { validateCorsOrigin, validateDataset, validateDocumentWebhook, 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) {
     return r.type.startsWith('sanity.function.');
 }
 export function isDocumentFunctionResource(r) {
-    return r.type === 'sanity.function.document';
+    return r.type === SANITY_FUNCTION_DOCUMENT;
 }
 export function isMediaLibraryAssetFunctionResource(r) {
-    return r.type === 'sanity.function.media-library.asset';
+    return r.type === SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
+}
+export function isScheduleFunctionResource(r) {
+    return r.type === SANITY_FUNCTION_SCHEDULE;
 }
 export function isLocalFunctionCollection(r) {
     return r.type === 'sanity.experimental.functions-collection';
 }
+export function isScheduleEvent(e) {
+    return e !== null && typeof e === 'object' && ('hour' in e || 'expression' in e);
+}
+export function isCorsOriginResource(r) {
+    return validateCorsOrigin(r).length === 0;
+}
+export function isRoleResource(r) {
+    return validateRole(r).length === 0;
+}
+export function isDatasetResource(r) {
+    return validateDataset(r).length === 0;
+}
+export function isWebhookResource(r) {
+    return validateDocumentWebhook(r).length === 0;
+}
 export function isEventType(arg) {
     return ['create', 'update', 'delete'].includes(arg);
 }
+export function isGroqContextOptions(context) {
+    return 'clientOptions' in context;
+}
 /** @internal */
 export var BlueprintParserErrorType;
 (function (BlueprintParserErrorType) {

package/dist/utils/validate/resource.js

@@ -1,4 +1,4 @@
-import { BlueprintParserErrorType, isDocumentFunctionResource, isMediaLibraryAssetFunctionResource, } from '../types.js';
+import { BlueprintParserErrorType, isDocumentFunctionResource, isMediaLibraryAssetFunctionResource, isScheduleEvent, } from '../types.js';
 export function validateFunctionName(name) {
     // must be 3+ characters, no special characters, no spaces, allow _ and -
     return /^[a-zA-Z0-9][a-zA-Z0-9_-]{2,}$/.test(name);
@@ -20,29 +20,68 @@ export function validateFunctionResource(resource) {
             type: BlueprintParserErrorType.InvalidType,
         });
     }
-    if (!resource.event || !Array.isArray(resource.event.on) || resource.event.on.length === 0) {
-        errors.push({
-            message: `${msgPrefix} event.on must be a non-empty array`,
-            type: BlueprintParserErrorType.MissingRequiredProperty,
-        });
-    }
-    else if (!resource.event.on.every((evt) => validFunctionEventNames.includes(evt))) {
-        errors.push({
-            message: `${msgPrefix} event.on values must be one of ${validFunctionEventNames.map((e) => `"${e}"`).join(', ')}`,
-            type: BlueprintParserErrorType.InvalidValue,
-        });
-    }
-    if (resource.event?.filter && typeof resource.event.filter !== 'string') {
-        errors.push({
-            message: `${msgPrefix} event.filter must be a string`,
-            type: BlueprintParserErrorType.InvalidType,
-        });
+    if (isScheduleEvent(resource.event)) {
+        const event = resource.event;
+        const hasExpression = 'expression' in event;
+        const hasExplicitFields = 'minute' in event ||
+            'hour' in event ||
+            'dayOfMonth' in event ||
+            'month' in event ||
+            'dayOfWeek' in event;
+        if (hasExpression && hasExplicitFields) {
+            errors.push({
+                type: BlueprintParserErrorType.InvalidFormat,
+                message: 'Cannot specify both `expression` and explicit cron fields (`minute`, `hour`, `dayOfMonth`, `month`, `dayOfWeek`)',
+            });
+        }
+        else if (!hasExpression && !hasExplicitFields) {
+            errors.push({
+                type: BlueprintParserErrorType.MissingRequiredProperty,
+                message: 'Either `expression` or explicit cron fields (`minute`, `hour`, `dayOfMonth`, `month`, `dayOfWeek`) must be provided',
+            });
+        }
+        else if (hasExpression) {
+            const expressionParts = event.expression.split(' ');
+            if (expressionParts.length !== 5) {
+                errors.push({
+                    type: BlueprintParserErrorType.InvalidFormat,
+                    message: 'Invalid `expression` format. Cron fields (`minute`, `hour`, `dayOfMonth`, `month`, `dayOfWeek`) must be provided',
+                });
+            }
+            else {
+                const [minute, hour, dayOfWeek, month, dayOfMonth] = expressionParts;
+                errors.push(...validateScheduleEvent(msgPrefix, { minute, hour, dayOfWeek, month, dayOfMonth }));
+            }
+        }
+        else if (hasExplicitFields) {
+            errors.push(...validateScheduleEvent(msgPrefix, event));
+        }
     }
-    if (resource.event?.projection && typeof resource.event.projection !== 'string') {
-        errors.push({
-            message: `${msgPrefix} event.projection must be a string`,
-            type: BlueprintParserErrorType.InvalidType,
-        });
+    else {
+        if (!resource.event || !Array.isArray(resource.event.on) || resource.event.on.length === 0) {
+            errors.push({
+                message: `${msgPrefix} event.on must be a non-empty array`,
+                type: BlueprintParserErrorType.MissingRequiredProperty,
+            });
+        }
+        else if (!resource.event.on.every((evt) => validFunctionEventNames.includes(evt))) {
+            errors.push({
+                message: `${msgPrefix} event.on values must be one of ${validFunctionEventNames.map((e) => `"${e}"`).join(', ')}`,
+                type: BlueprintParserErrorType.InvalidValue,
+            });
+        }
+        if (resource.event?.filter && typeof resource.event.filter !== 'string') {
+            errors.push({
+                message: `${msgPrefix} event.filter must be a string`,
+                type: BlueprintParserErrorType.InvalidType,
+            });
+        }
+        if (resource.event?.projection && typeof resource.event.projection !== 'string') {
+            errors.push({
+                message: `${msgPrefix} event.projection must be a string`,
+                type: BlueprintParserErrorType.InvalidType,
+            });
+        }
     }
     if (resource.memory !== undefined) {
         if (!Number.isInteger(resource.memory)) {
@@ -150,3 +189,85 @@ export function validateFunctionResource(resource) {
     }
     return errors;
 }
+function validateScheduleEvent(msgPrefix, event) {
+    const errors = [];
+    const properties = [
+        { name: 'minute', regex: MINUTES },
+        { name: 'hour', regex: HOURS },
+        { name: 'dayOfMonth', regex: DAY_OF_MONTH },
+        { name: 'month', regex: MONTH },
+        { name: 'dayOfWeek', regex: DAY_OF_WEEK },
+    ];
+    properties.forEach((prop) => {
+        const { name, regex } = prop;
+        if (!(name in event)) {
+            errors.push({
+                type: BlueprintParserErrorType.MissingRequiredProperty,
+                message: `${msgPrefix} '${name}' must be provided`,
+            });
+            return;
+        }
+        const value = event[name];
+        if (typeof value !== 'string') {
+            errors.push({
+                type: BlueprintParserErrorType.InvalidType,
+                message: `${msgPrefix} '${name}' must be a string`,
+            });
+            return;
+        }
+        if (!isValidCronPart(regex, value)) {
+            errors.push({
+                type: BlueprintParserErrorType.InvalidValue,
+                message: `${msgPrefix} ${name} field contains invalid value: ${value}`,
+            });
+        }
+    });
+    return errors;
+}
+/**
+ * Validates that each cron part adheres to it's rules
+ *
+ * @param {RegExp} regex the regular expression that corresponds to the part of the cron expression you are testing
+ * @param {string} value the string value of part of the cron expression you are testing
+ * @returns {boolean} whether or not the cron part is valid
+ */
+function isValidCronPart(regex, value) {
+    return regex.test(value) && checkAscendingRanges(value) && checkNoZeroStep(value);
+}
+const MINUTES = /^(\*(\/([1-5]?\d))?|([0-5]?\d)(-[0-5]?\d)?(\/([1-5]?\d))?)(,(\*(\/([1-5]?\d))?|([0-5]?\d)(-[0-5]?\d)?(\/([1-5]?\d))?))*$/;
+const HOURS = /^(\*(\/([1-9]|1\d|2[0-3]))?|([01]?\d|2[0-3])(-([01]?\d|2[0-3]))?(\/([1-9]|1\d|2[0-3]))?)(,(\*(\/([1-9]|1\d|2[0-3]))?|([01]?\d|2[0-3])(-([01]?\d|2[0-3]))?(\/([1-9]|1\d|2[0-3]))?))*$/;
+const DAY_OF_MONTH = /^(\*(\/([1-9]|[12]\d|3[01]))?|([1-9]|[12]\d|3[01])(-([1-9]|[12]\d|3[01]))?(\/([1-9]|[12]\d|3[01]))?)(,(\*(\/([1-9]|[12]\d|3[01]))?|([1-9]|[12]\d|3[01])(-([1-9]|[12]\d|3[01]))?(\/([1-9]|[12]\d|3[01]))?))*$/;
+const MONTH = /^(\*(\/([1-9]|1[0-2]))?|([1-9]|1[0-2]|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)(-([1-9]|1[0-2]|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC))?(\/([1-9]|1[0-2]))?)(,(\*(\/([1-9]|1[0-2]))?|([1-9]|1[0-2]|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)(-([1-9]|1[0-2]|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC))?(\/([1-9]|1[0-2]))?))*$/i;
+const DAY_OF_WEEK = /^(\*(\/([0-7]))?|([0-7]|SUN|MON|TUE|WED|THU|FRI|SAT)(-([0-7]|SUN|MON|TUE|WED|THU|FRI|SAT))?(\/([0-7]))?)(,(\*(\/([0-7]))?|([0-7]|SUN|MON|TUE|WED|THU|FRI|SAT)(-([0-7]|SUN|MON|TUE|WED|THU|FRI|SAT))?(\/([0-7]))?))*$/i;
+/**
+ *
+ * @param {string} value the string value of part of the cron expression you are testing
+ * @returns {boolean} returns true if the range is valid
+ */
+function checkAscendingRanges(value) {
+    for (const part of value.split(',')) {
+        if (part.includes('-')) {
+            const [start, right] = part.split('-');
+            const end = right.split('/')[0]; // remove /step
+            const s = Number(start);
+            const e = Number(end);
+            if (s > e)
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * @param {string} value the string value of part of the cron expression you are testing
+ * @returns {boolean} makes sure we are not trying to divide by zero
+ */
+function checkNoZeroStep(value) {
+    for (const part of value.split(',')) {
+        if (part.includes('/')) {
+            const step = Number(part.split('/')[1]);
+            if (step === 0)
+                return false;
+        }
+    }
+    return true;
+}

package/oclif.manifest.json

@@ -397,6 +397,12 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "fix": {
+          "description": "Interactively fix configuration issues",
+          "name": "fix",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -868,6 +874,13 @@
         "<%= config.bin %> <%= command.id %> --host 127.0.0.1 --port 8974"
       ],
       "flags": {
+        "verbose": {
+          "description": "Verbose output",
+          "hidden": true,
+          "name": "verbose",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "host": {
           "char": "h",
           "description": "The local network interface at which to listen. [default: \"localhost\"]",
@@ -1416,5 +1429,5 @@
       ]
     }
   },
-  "version": "12.1.0"
+  "version": "12.2.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "12.1.0",
+  "version": "12.2.0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -83,6 +83,7 @@
     "@inquirer/prompts": "^8.0.1",
     "@oclif/core": "^4.8.0",
     "@oclif/plugin-help": "^6.2.36",
+    "@sanity/blueprints": "^0.7.0",
     "@sanity/blueprints-parser": "^0.3.0",
     "@sanity/client": "^7.13.0",
     "adm-zip": "^0.5.16",
@@ -112,7 +113,6 @@
     "@oclif/test": "^4.1.15",
     "@playwright/test": "^1.56.1",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@sanity/blueprints": "^0.6.0",
     "@sanity/functions": "^1.1.0",
     "@types/adm-zip": "^0.5.7",
     "@types/cardinal": "^2.1.1",