@sanity/runtime-cli 14.3.0 → 14.5.0

package/dist/cores/functions/logs.js

@@ -74,7 +74,7 @@ async function streamLogs({ name, externalId, auth, log, }) {
 }
 async function getLogs({ name, externalId, auth, limit, json, utc, log, }) {
     const spinner = log.ora(`Finding logs for function "${name}"`).start();
-    const { ok, error, logs, total } = await getLogsAction(externalId, { limit }, auth, log);
+    const { ok, error, logs } = await getLogsAction(externalId, { limit }, auth, log);
     if (!ok) {
         spinner.fail(`${styleText('red', 'Failed')} to retrieve logs`);
         return { success: false, error: error || 'Unknown error' };
@@ -86,10 +86,8 @@ async function getLogs({ name, externalId, auth, limit, json, utc, log, }) {
     }
     spinner.succeed(`${formatTitle('Function', name)} Logs`);
     if (!json) {
-        log(`Found ${styleText('bold', String(total))} log entries for function ${styleText('yellow', name)}`);
-        if (logs.length < total) {
-            log(`Here are the last ${styleText('bold', filteredLogs.length.toString())} entries`);
-        }
+        const logLength = filteredLogs.length;
+        log(`Found ${styleText('bold', logLength.toString())} log ${logLength === 1 ? 'entry' : 'entries'} for function ${styleText('yellow', name)}`);
         log('\n');
         for (const { time, level, message } of filteredLogs) {
             log(formatLog(time, level, message, utc));

package/dist/cores/functions/test.js

@@ -135,7 +135,7 @@ export async function functionTestCore(options) {
                 after,
             }
             : {
-                event: 'schedule',
+                event: 'scheduled',
             };
         const spinner = log.ora('Executing function...').start();
         const { json, logs, error } = await testAction(resource, invokeOptions, contextOptions, {

package/dist/server/app.js

@@ -329,13 +329,13 @@ function parseInvokeRequest(body) {
     }
     const metadataEvent = metadata.event;
     if (typeof metadataEvent !== 'string' ||
-        (!isEventType(metadataEvent) && metadataEvent !== 'schedule')) {
-        throw new Error('Request body is not valid, `metadata.event` field is not one of `create`, `update`, `delete`, or `schedule`');
+        (!isEventType(metadataEvent) && metadataEvent !== 'scheduled')) {
+        throw new Error('Request body is not valid, `metadata.event` field is not one of `create`, `update`, `delete`, or `scheduled`');
     }
     let before = null;
     let after = null;
     // Only GROQ-based events (create, update, delete) have before and after fields
-    if (metadataEvent !== 'schedule') {
+    if (metadataEvent !== 'scheduled') {
         if (!('before' in metadata)) {
             throw new Error('Request body is not valid, `metadata.before` field is missing');
         }
@@ -374,7 +374,9 @@ function parseInvokeRequest(body) {
             },
             event,
         },
-        metadata: metadataEvent === 'schedule' ? { event: metadataEvent } : { event: metadataEvent, before, after },
+        metadata: metadataEvent === 'scheduled'
+            ? { event: metadataEvent }
+            : { event: metadataEvent, before, after },
     };
 }
 export { app, buildApiUrl, parseDocumentUrl };

package/dist/server/static/components/api-base.js

@@ -9,6 +9,6 @@ export class ApiBaseElement extends HTMLElement {
     this.api = api
     this.SANITY_FUNCTION_DOCUMENT = 'sanity.function.document'
     this.SANITY_FUNCTION_MEDIA_LIBRARY_ASSET = 'sanity.function.media-library.asset'
-    this.SANITY_FUNCTION_SCHEDULE = 'sanity.function.cron'
+    this.SANITY_FUNCTION_SCHEDULED = 'sanity.function.cron'
   }
 }

package/dist/server/static/components/filters.js

@@ -79,7 +79,7 @@ class FiltersComponent extends ApiBaseElement {
     const mediaFunction = this.api.store.selectedFunctionType?.startsWith(
       this.SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
     )
-    const scheduleFunction = this.api.store.selectedFunctionType === this.SANITY_FUNCTION_SCHEDULE
+    const scheduleFunction = this.api.store.selectedFunctionType === this.SANITY_FUNCTION_SCHEDULED
 
     const container = this.shadowRoot.querySelector('fieldset')
     container.innerHTML = this.buildFilters(docFunction, mediaFunction, scheduleFunction)

package/dist/server/static/components/function-list.js

@@ -58,8 +58,8 @@ class FunctionList extends ApiBaseElement {
         return 'Document'
       case this.SANITY_FUNCTION_MEDIA_LIBRARY_ASSET:
         return 'Media Library'
-      case this.SANITY_FUNCTION_SCHEDULE:
-        return 'Schedule'
+      case this.SANITY_FUNCTION_SCHEDULED:
+        return 'Scheduled'
       default:
         return type.split('.').pop().replaceAll('-', ' ')
     }

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

@@ -79,7 +79,7 @@ class PayloadPanel extends ApiBaseElement {
   }
 
   updateCodeMirror = ({selectedFunctionType}) => {
-    if (selectedFunctionType === this.SANITY_FUNCTION_SCHEDULE) {
+    if (selectedFunctionType === this.SANITY_FUNCTION_SCHEDULED) {
       this.api.store.beforePayload.dispatch({
         effects: editableCompartment.reconfigure(EditorView.editable.of(false)),
       })

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

@@ -25,7 +25,7 @@ class RunPanel extends ApiBaseElement {
     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 scheduleFunction = this.api.store.selectedFunctionType === this.SANITY_FUNCTION_SCHEDULED
     const docOrScheduleFunction = docFunction || scheduleFunction
 
     this.api.store.result = {logs: '', time: 0}
@@ -58,7 +58,7 @@ class RunPanel extends ApiBaseElement {
         token: this.api.store.withToken,
       },
       eventResourceType: scheduleFunction
-        ? 'schedule'
+        ? 'scheduled'
         : mediaFunction
           ? 'media-library'
           : 'dataset',

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

@@ -1,5 +1,5 @@
 import { treeify } from 'array-treeify';
-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 { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
 import { styleText } from '../style-text.js';
 import { isCorsOriginResource, isDatasetResource, isRobotResource, isRoleResource, isWebhookResource, } from '../types.js';
 import { formatDate, formatDuration } from './dates.js';
@@ -19,7 +19,7 @@ const RESOURCE_CATEGORIES = {
         },
     },
     [SANITY_ACCESS_ROBOT]: {
-        label: 'Robots',
+        label: 'Robot Tokens',
         displayNameAttribute: 'label',
         formatDetails(res) {
             return isRobotResource(res) ? arrayifyRobot(res) : [];
@@ -27,7 +27,14 @@ const RESOURCE_CATEGORIES = {
     },
     [SANITY_FUNCTION_DOCUMENT]: functionCategory,
     [SANITY_FUNCTION_MEDIA_LIBRARY_ASSET]: functionCategory,
-    [SANITY_FUNCTION_SCHEDULE]: functionCategory,
+    [SANITY_FUNCTION_SCHEDULED]: functionCategory,
+    [SANITY_PROJECT]: {
+        label: 'Projects',
+        displayNameAttribute: 'displayName',
+        formatDetails(_res) {
+            return [];
+        },
+    },
     [SANITY_PROJECT_CORS]: {
         label: 'CORS Origins',
         formatDetails(res) {
@@ -212,12 +219,12 @@ export function formatStacksListing(stacks, currentStackId) {
 const IGNORED_PARAMS = {
     [SANITY_FUNCTION_DOCUMENT]: new Set(['src']),
     [SANITY_FUNCTION_MEDIA_LIBRARY_ASSET]: new Set(['src']),
-    [SANITY_FUNCTION_SCHEDULE]: new Set(['src']),
+    [SANITY_FUNCTION_SCHEDULED]: new Set(['src']),
 };
 const ASSET_RESOURCE_TYPES = new Set([
     SANITY_FUNCTION_DOCUMENT,
     SANITY_FUNCTION_MEDIA_LIBRARY_ASSET,
-    SANITY_FUNCTION_SCHEDULE,
+    SANITY_FUNCTION_SCHEDULED,
 ]);
 function stringifyUnknown(val) {
     if (val === null || val === undefined)

package/dist/utils/find-function.js

@@ -1,17 +1,18 @@
+import { SANITY_FUNCTION_PREFIX } from '../constants.js';
 export function getFunctionNames(resources) {
     return (resources
-        ?.filter((r) => r?.type?.startsWith('sanity.function.'))
+        ?.filter((r) => r?.type?.startsWith(SANITY_FUNCTION_PREFIX))
         .map((r) => r.name)
         .filter((name) => typeof name === 'string') ?? []);
 }
 export function findFunctionInBlueprint(blueprint, name) {
-    const func = blueprint?.resources?.find((r) => r?.type?.startsWith('sanity.function.') && r.name === name);
+    const func = blueprint?.resources?.find((r) => r?.type?.startsWith(SANITY_FUNCTION_PREFIX) && r.name === name);
     if (!func)
         throw Error(`Unable to find function ${name}`);
     return func;
 }
 export function findFunctionInStack(stack, name) {
-    const func = stack?.resources?.find((r) => r?.type?.startsWith('sanity.function.') && r.name === name);
+    const func = stack?.resources?.find((r) => r?.type?.startsWith(SANITY_FUNCTION_PREFIX) && r.name === name);
     if (!func)
         throw Error(`Unable to find function: "${name}"`);
     if (!isDeployedResource(func))

package/dist/utils/functions/detect-native-modules.d.ts

@@ -1,6 +1,12 @@
 import type AdmZip from 'adm-zip';
+import type { FunctionResource } from '../types.js';
 /**
- * Scan zip entries of dependencies for native modules.
+ * Recurse node_modules for native modules.
  * Native modules built on one platform may not work on another (e.g., macOS vs Linux)
  */
 export declare const detectNativeModules: (zip: AdmZip) => string[];
+/**
+ * Finds the dependencies of the function and compares to the workspace root to see if any native modules are included.
+ * Due to how PNPM with workspaces symlinks dependencies, we have to check the workspace root for native modules prior to the bundle step.
+ */
+export declare const detectNativeModulesForBundle: (resource: FunctionResource) => string[];

package/dist/utils/functions/detect-native-modules.js

@@ -1,9 +1,13 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { cwd } from 'node:process';
+import { createPnpmRequire } from '../pnpm.js';
 /**
  * Patterns to identify native modules based on common file types and build configurations.
  */
 const KNOWN_MODULE_PATTERNS = [/binding\.gyp$/, /\.node$/];
 /**
- * Scan zip entries of dependencies for native modules.
+ * Recurse node_modules for native modules.
  * Native modules built on one platform may not work on another (e.g., macOS vs Linux)
  */
 export const detectNativeModules = (zip) => {
@@ -24,3 +28,67 @@ export const detectNativeModules = (zip) => {
         throw new Error(`Failed to scan zip for native modules: ${message}`);
     }
 };
+/**
+ * Recursively checks a directory for files that match known native module patterns.
+ */
+const hasNativeFiles = (directory) => {
+    for (const name of readdirSync(directory)) {
+        // don't recurse back into node_modules.
+        if (name === 'node_modules')
+            continue;
+        const fullPath = path.join(directory, name);
+        if (statSync(fullPath).isDirectory()) {
+            if (hasNativeFiles(fullPath))
+                return true;
+        }
+        else if (KNOWN_MODULE_PATTERNS.some((pattern) => pattern.test(name))) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Finds the dependencies of the function and compares to the workspace root to see if any native modules are included.
+ * Due to how PNPM with workspaces symlinks dependencies, we have to check the workspace root for native modules prior to the bundle step.
+ */
+export const detectNativeModulesForBundle = (resource) => {
+    if (!resource.src)
+        throw new Error('Resource src is required');
+    const hasWorkspace = existsSync(path.join(cwd(), 'pnpm-workspace.yaml'));
+    if (!hasWorkspace) {
+        return [];
+    }
+    const sourcePath = path.resolve(cwd(), resource.src);
+    const stats = statSync(sourcePath);
+    const entryDir = stats.isFile() ? path.dirname(sourcePath) : sourcePath;
+    const hasPackageJson = existsSync(path.join(entryDir, 'package.json'));
+    if (!hasPackageJson) {
+        throw new Error('pnpm workspace detected but no package.json found in function src');
+    }
+    // gets package.json dependencies of the function. We use these function deps to compare against the workspace root modules.
+    const pkgJsonPath = path.join(entryDir, 'package.json');
+    // a function should always have deps, but this will just be a little safer.
+    const functionDeps = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')).dependencies ?? {};
+    const workspaceModules = createPnpmRequire(cwd());
+    const nativeModules = [];
+    for (const depName of Object.keys(functionDeps)) {
+        try {
+            const resolved = workspaceModules.resolve(depName);
+            let currentDir = path.dirname(resolved);
+            while (currentDir !== cwd() && currentDir !== path.parse(currentDir).root) {
+                // look for node_module package.json to locate top level
+                if (existsSync(path.join(currentDir, 'package.json'))) {
+                    if (hasNativeFiles(currentDir)) {
+                        nativeModules.push(depName);
+                        break;
+                    }
+                }
+                currentDir = path.dirname(currentDir);
+            }
+        }
+        catch (_e) {
+            // If we fail to resolve, just skip
+        }
+    }
+    return nativeModules;
+};

package/dist/utils/functions/prepare-asset.d.ts

@@ -1,6 +1,8 @@
-import type { CollectionFunction, FunctionResource } from '../types.js';
+import type { CollectionFunction, FunctionResource, InstallerType } from '../types.js';
 export declare function prepareAsset({ resource, }: {
     resource: FunctionResource | CollectionFunction;
+}, { installer }?: {
+    installer?: InstallerType;
 }): Promise<{
     success: boolean;
     outputPath?: string;

package/dist/utils/functions/prepare-asset.js

@@ -1,12 +1,14 @@
+import { rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { cwd } from 'node:process';
 import { MAX_ASSET_SIZE } from '../../constants.js';
 import { transpileFunction } from '../transpile/transpile-function.js';
+import { detectNativeModulesForBundle } from './detect-native-modules.js';
 import { getFolderSize } from './getFolderSize.js';
 import { resolveResourceDependencies } from './resolve-dependencies.js';
 import { shouldAutoResolveDependencies } from './should-auto-resolve-deps.js';
 import { shouldTranspileFunction } from './should-transpile.js';
-export async function prepareAsset({ resource, }) {
+export async function prepareAsset({ resource, }, { installer } = {}) {
     if (!resource.src)
         throw new Error('Resource src is required');
     let functionPath = path.join(cwd(), resource.src);
@@ -15,7 +17,13 @@ export async function prepareAsset({ resource, }) {
     const shouldTranspile = await shouldTranspileFunction(resource);
     if (shouldTranspile) {
         try {
-            const result = await transpileFunction(resource);
+            const hasNativeModules = detectNativeModulesForBundle(resource);
+            if (hasNativeModules.length) {
+                const errorMsg = `Native modules detected:\n${hasNativeModules.join('\n')}\n\n` +
+                    `Please replace with JavaScript alternatives.`;
+                throw new Error(errorMsg);
+            }
+            const result = await transpileFunction(resource, { installer });
             functionPath = result.outputDir;
             cleanup = result.cleanup;
             wasBundled = result.bundled;
@@ -26,7 +34,8 @@ export async function prepareAsset({ resource, }) {
     }
     const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
     if (shouldResolveDependencies && !wasBundled) {
-        await resolveResourceDependencies(resource, shouldTranspile);
+        await resolveResourceDependencies(resource, { transpiled: shouldTranspile, installer });
+        await removeArcAutoInstallPackageJson(functionPath);
     }
     try {
         const size = getFolderSize(functionPath);
@@ -39,3 +48,19 @@ export async function prepareAsset({ resource, }) {
         return { success: false, error: err instanceof Error ? err.message : `${err}` };
     }
 }
+/**
+ * Remove file that contains the current date to prevent the hash from changing in the final asset.
+ * @param functionPath The path to the built function
+ */
+async function removeArcAutoInstallPackageJson(functionPath) {
+    const arcAutoInstallPackageJson = path.join(functionPath, 'node_modules', '_arc-autoinstall', 'package.json');
+    try {
+        const fileStat = await stat(arcAutoInstallPackageJson);
+        if (fileStat.isFile()) {
+            await rm(arcAutoInstallPackageJson);
+        }
+    }
+    catch {
+        // ignore errors
+    }
+}

package/dist/utils/functions/resolve-dependencies.d.ts

@@ -1,2 +1,5 @@
-import type { FunctionResource } from '../types.js';
-export declare function resolveResourceDependencies(resource: FunctionResource, transpiled: boolean): Promise<void>;
+import type { FunctionResource, InstallerType } from '../types.js';
+export declare function resolveResourceDependencies(resource: FunctionResource, { transpiled, installer, }: {
+    transpiled: boolean;
+    installer?: InstallerType;
+}): Promise<void>;

package/dist/utils/functions/resolve-dependencies.js

@@ -3,25 +3,22 @@ import { join } from 'node:path';
 import hydrate from '@architect/hydrate';
 import inventory from '@architect/inventory';
 import { convertResourceToArcFormat } from './resource-to-arc.js';
-export async function resolveResourceDependencies(resource, transpiled) {
+export async function resolveResourceDependencies(resource, { transpiled, installer, }) {
     const rawArc = await convertResourceToArcFormat(resource, transpiled);
     const inv = await inventory({ rawArc });
     const cwd = inv.inv._project.cwd;
-    const installOptions = {
-        inventory: inv,
-        hydrateShared: false,
-        quiet: true,
-        pnpm: false,
-        yarn: false,
-    };
-    if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
-        installOptions.pnpm = true;
+    let installType = 'npm';
+    if (installer) {
+        installType = installer;
+    }
+    else if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
+        installType = 'pnpm';
     }
     else if (existsSync(join(cwd, 'yarn.lock'))) {
-        installOptions.yarn = true;
+        installType = 'yarn';
     }
     try {
-        await hydrate.install(installOptions);
+        await hydrate.install(toInstallerOptions(inv, installType));
     }
     catch (err) {
         // This is a temporary fix.
@@ -32,3 +29,13 @@ export async function resolveResourceDependencies(resource, transpiled) {
         }
     }
 }
+function toInstallerOptions(inv, type) {
+    return {
+        inventory: inv,
+        hydrateShared: false,
+        quiet: true,
+        npm: type === 'npm',
+        pnpm: type === 'pnpm',
+        yarn: type === 'yarn',
+    };
+}

package/dist/utils/invoke-local.js

@@ -84,7 +84,7 @@ export default async function invoke(resource, payload, context, options) {
     }
     const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
     if (shouldResolveDependencies && existingPackageJson) {
-        await resolveResourceDependencies(resource, shouldTranspile);
+        await resolveResourceDependencies(resource, { transpiled: shouldTranspile });
     }
     if (!existingPackageJson) {
         createTempPackageJson(functionPath);

package/dist/utils/pnpm.d.ts

@@ -0,0 +1 @@
+export declare const createPnpmRequire: (workspaceRoot: string) => NodeJS.Require;

package/dist/utils/pnpm.js

@@ -0,0 +1,9 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+export const createPnpmRequire = (workspaceRoot) => {
+    const pnpmModulesPath = path.join(workspaceRoot, 'node_modules', '.pnpm', 'node_modules');
+    // createRequire gives us Node's full module resolution algorithm rooted at
+    // the pnpm virtual store — it reads package.json exports/main and returns
+    // the absolute path to the actual entry file, not just the directory.
+    return createRequire(path.join(pnpmModulesPath, '_virtual.js'));
+};

package/dist/utils/transpile/transpile-function.d.ts

@@ -1,5 +1,7 @@
-import type { FunctionResource } from '../types.js';
-export declare function transpileFunction(resource: FunctionResource): Promise<{
+import type { FunctionResource, InstallerType } from '../types.js';
+export declare function transpileFunction(resource: FunctionResource, { installer }?: {
+    installer?: InstallerType;
+}): Promise<{
     type: string;
     outputDir: string;
     warnings: string[];

package/dist/utils/transpile/transpile-function.js

@@ -1,6 +1,5 @@
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { cwd } from 'node:process';
@@ -8,9 +7,10 @@ import * as find from 'empathic/find';
 import { build as viteBuild } from 'vite';
 import tsConfigPaths from 'vite-tsconfig-paths';
 import { findFunctionEntryPoint } from '../functions/find-entry-point.js';
+import { createPnpmRequire } from '../pnpm.js';
 import { cleanupSourceMaps } from './cleanup-source-maps.js';
 import { verifyHandler } from './verify-handler.js';
-export async function transpileFunction(resource) {
+export async function transpileFunction(resource, { installer } = {}) {
     if (!resource.src)
         throw new Error('Resource src is required');
     if (!resource.name)
@@ -35,7 +35,8 @@ export async function transpileFunction(resource) {
     }
     try {
         const viteStart = performance.now();
-        const bundle = existsSync(path.join(cwd(), 'pnpm-workspace.yaml'));
+        // Always bundle the code if pnpm usage is detected or specified by the user
+        const bundle = existsSync(path.join(cwd(), 'pnpm-workspace.yaml')) || installer === 'pnpm';
         const result = await viteBuild({
             root: fnRootDir,
             logLevel: 'silent',
@@ -140,11 +141,7 @@ function logCleanupFailure(err) {
  * which isn't reachable via standard Node resolution.
  */
 function pnpmResolvePlugin(workspaceRoot) {
-    const pnpmModulesPath = path.join(workspaceRoot, 'node_modules', '.pnpm', 'node_modules');
-    // createRequire gives us Node's full module resolution algorithm rooted at
-    // the pnpm virtual store — it reads package.json exports/main and returns
-    // the absolute path to the actual entry file, not just the directory.
-    const pnpmRequire = createRequire(path.join(pnpmModulesPath, '_virtual.js'));
+    const pnpmRequire = createPnpmRequire(workspaceRoot);
     return {
         name: 'pnpm-resolve',
         async resolveId(source, importer, options) {

package/dist/utils/types.d.ts

@@ -1,6 +1,6 @@
-import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentWebhookResource, type BlueprintResource, type BlueprintRobotResource, type BlueprintRoleResource } from '@sanity/blueprints';
+import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentWebhookResource, type BlueprintProjectResource, 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';
+import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED } from '../constants.js';
 export type ScopeType = 'organization' | 'project';
 /** Result utility type */
 export type Result<T, E = string> = {
@@ -65,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 isProjectResource(r: unknown): r is BlueprintProjectResource;
 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;
@@ -91,11 +92,11 @@ interface FunctionResourceMediaLibraryAsset extends FunctionResourceBase {
     event: GroqRuleMediaLibraryFunction;
 }
 interface FunctionResourceSchedule extends FunctionResourceBase {
-    type: typeof SANITY_FUNCTION_SCHEDULE;
+    type: typeof SANITY_FUNCTION_SCHEDULED;
     event: FunctionResourceScheduleEvent;
 }
 export interface CollectionFunction {
-    type: typeof SANITY_FUNCTION_DOCUMENT | typeof SANITY_FUNCTION_SCHEDULE | typeof SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
+    type: typeof SANITY_FUNCTION_DOCUMENT | typeof SANITY_FUNCTION_SCHEDULED | typeof SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
     src: string;
     name: string;
     displayName?: string;
@@ -159,7 +160,7 @@ export interface InvokeGroqPayloadOptions {
 }
 export interface InvokeSchedulePayloadOptions {
     payload?: Record<string, unknown>;
-    event: 'schedule';
+    event: 'scheduled';
 }
 export type InvokePayloadOptions = InvokeGroqPayloadOptions | InvokeSchedulePayloadOptions;
 export type InvokePayloadMetadata = Pick<InvokeGroqPayloadOptions, 'event' | 'before' | 'after'> | Pick<InvokeSchedulePayloadOptions, 'event'>;
@@ -254,4 +255,6 @@ export declare interface FetchConfig {
     apiHost?: string;
     apiVersion?: string;
 }
+export declare const INSTALLER_OPTIONS: readonly ["npm", "pnpm", "yarn"];
+export type InstallerType = 'npm' | 'pnpm' | 'yarn';
 export {};

package/dist/utils/types.js

@@ -1,8 +1,8 @@
-import { validateCorsOrigin, validateDataset, validateDocumentWebhook, validateRobot, validateRole, } from '@sanity/blueprints';
-import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULE, } from '../constants.js';
+import { validateCorsOrigin, validateDataset, validateDocumentWebhook, validateProject, validateRobot, validateRole, } from '@sanity/blueprints';
+import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PREFIX, SANITY_FUNCTION_SCHEDULED, } from '../constants.js';
 // type narrowing with predicate functions
 export function isLocalFunctionResource(r) {
-    return r.type.startsWith('sanity.function.');
+    return r.type.startsWith(SANITY_FUNCTION_PREFIX);
 }
 export function isDocumentFunctionResource(r) {
     return r.type === SANITY_FUNCTION_DOCUMENT;
@@ -11,7 +11,7 @@ export function isMediaLibraryAssetFunctionResource(r) {
     return r.type === SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
 }
 export function isScheduleFunctionResource(r) {
-    return r.type === SANITY_FUNCTION_SCHEDULE;
+    return r.type === SANITY_FUNCTION_SCHEDULED;
 }
 export function isLocalFunctionCollection(r) {
     return r.type === 'sanity.experimental.functions-collection';
@@ -22,6 +22,9 @@ export function isScheduleEvent(e) {
 export function isCorsOriginResource(r) {
     return validateCorsOrigin(r).length === 0;
 }
+export function isProjectResource(r) {
+    return validateProject(r).length === 0;
+}
 export function isRobotResource(r) {
     return validateRobot(r).length === 0;
 }
@@ -54,3 +57,4 @@ export var BlueprintParserErrorType;
     BlueprintParserErrorType["InvalidInput"] = "invalid_input";
     BlueprintParserErrorType["MissingParameter"] = "missing_parameter";
 })(BlueprintParserErrorType || (BlueprintParserErrorType = {}));
+export const INSTALLER_OPTIONS = ['npm', 'pnpm', 'yarn'];

package/dist/utils/validate/index.js

@@ -1,5 +1,5 @@
-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';
+import { validateCorsOrigin, validateDataset, validateDocumentFunction, validateDocumentWebhook, validateMediaLibraryAssetFunction, validateProject, validateRole, validateScheduledFunction, } from '@sanity/blueprints';
+import { SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, } from '../../constants.js';
 export * as validate from './resource.js';
 const RESOURCE_VALIDATORS = {
     [SANITY_ACCESS_ROLE]: {
@@ -11,8 +11,11 @@ const RESOURCE_VALIDATORS = {
     [SANITY_FUNCTION_MEDIA_LIBRARY_ASSET]: {
         validate: validateMediaLibraryAssetFunction,
     },
-    [SANITY_FUNCTION_SCHEDULE]: {
-        validate: validateScheduleFunction,
+    [SANITY_FUNCTION_SCHEDULED]: {
+        validate: validateScheduledFunction,
+    },
+    [SANITY_PROJECT]: {
+        validate: validateProject,
     },
     [SANITY_PROJECT_CORS]: {
         validate: validateCorsOrigin,

package/dist/utils/validate/resource.js

@@ -1,3 +1,4 @@
+import { SANITY_FUNCTION_PREFIX } from '../../constants.js';
 import { BlueprintParserErrorType, isDocumentFunctionResource, isMediaLibraryAssetFunctionResource, isScheduleEvent, } from '../types.js';
 export function validateFunctionName(name) {
     // must be 3+ characters, no special characters, no spaces, allow _ and -
@@ -14,9 +15,9 @@ export function validateFunctionResource(resource) {
             type: BlueprintParserErrorType.InvalidProperty,
         });
     }
-    if (!resource.type.startsWith('sanity.function.')) {
+    if (!resource.type.startsWith(SANITY_FUNCTION_PREFIX)) {
         errors.push({
-            message: `${msgPrefix} Resource type must start with "sanity.function."`,
+            message: `${msgPrefix} Resource type must start with "${SANITY_FUNCTION_PREFIX}"`,
             type: BlueprintParserErrorType.InvalidType,
         });
     }