@sanity/runtime-cli 4.4.0 → 4.5.1

package/dist/utils/bundle/cleanup-source-maps.d.ts

@@ -0,0 +1,10 @@
+/**
+ * "Clean up" source maps by removing absolute paths and making paths relative to the
+ * _input_ (eg source) rather than the _output_ (eg bundle) directory. Note that this
+ * process is not critical since the source content is inlined, but it helps with
+ * debugging to have (approximate) paths to the original source files.
+ *
+ * @param inputDir - The directory where the source files are located
+ * @param outputDir - The directory where the bundled files are located
+ */
+export declare function cleanupSourceMaps(inputDir: string, outputDir: string): Promise<void>;

package/dist/utils/bundle/cleanup-source-maps.js

@@ -0,0 +1,53 @@
+import { promises as fs } from 'node:fs';
+import { isAbsolute, join, relative } from 'node:path';
+/**
+ * "Clean up" source maps by removing absolute paths and making paths relative to the
+ * _input_ (eg source) rather than the _output_ (eg bundle) directory. Note that this
+ * process is not critical since the source content is inlined, but it helps with
+ * debugging to have (approximate) paths to the original source files.
+ *
+ * @param inputDir - The directory where the source files are located
+ * @param outputDir - The directory where the bundled files are located
+ */
+export async function cleanupSourceMaps(inputDir, outputDir) {
+    const entries = await fs.readdir(outputDir, { withFileTypes: true });
+    const sourceMaps = entries.filter((entry) => entry.isFile() && entry.name.endsWith('.map'));
+    for (const entry of sourceMaps) {
+        const filePath = join(outputDir, entry.name);
+        let raw;
+        try {
+            raw = await fs.readFile(filePath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        let map;
+        try {
+            const json = JSON.parse(raw);
+            map = isRelevantSourceMap(json) ? json : undefined;
+        }
+        catch {
+            return;
+        }
+        if (!map) {
+            return;
+        }
+        map.sources = map.sources.map((source) => {
+            const fullPath = isAbsolute(source) ? source : join(outputDir, source);
+            return relative(inputDir, fullPath);
+        });
+        try {
+            await fs.writeFile(filePath, JSON.stringify(map));
+        }
+        catch {
+            // ignore write errors
+        }
+    }
+}
+function isRelevantSourceMap(map) {
+    return (typeof map === 'object' &&
+        map !== null &&
+        'sources' in map &&
+        Array.isArray(map.sources) &&
+        map.sources.every((source) => typeof source === 'string'));
+}

package/dist/utils/bundle/find-up.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Walks up the directory tree from a starting point to find a given file/directory.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The path to the file if found, otherwise undefined.
+ */
+export declare function findUp(fileName: string, startDir?: string): Promise<string | undefined>;
+/**
+ * Finds the directory containing a specific file/directory by walking up the directory tree.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The directory containing the file if found, otherwise undefined.
+ */
+export declare function findDirUp(fileName: string, startDir?: string): Promise<string | undefined>;

package/dist/utils/bundle/find-up.js

@@ -0,0 +1,39 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Walks up the directory tree from a starting point to find a given file/directory.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The path to the file if found, otherwise undefined.
+ */
+export async function findUp(fileName, startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(dir, fileName);
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break; // Reached root
+            dir = parent;
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds the directory containing a specific file/directory by walking up the directory tree.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The directory containing the file if found, otherwise undefined.
+ */
+export async function findDirUp(fileName, startDir = process.cwd()) {
+    const filePath = await findUp(fileName, startDir);
+    if (!filePath)
+        return undefined;
+    return path.dirname(filePath);
+}

package/dist/utils/bundle/verify-handler.d.ts

@@ -0,0 +1,2 @@
+import type { build } from 'vite';
+export declare function verifyHandler(result: Awaited<ReturnType<typeof build>>): Promise<void>;

package/dist/utils/bundle/verify-handler.js

@@ -0,0 +1,13 @@
+export async function verifyHandler(result) {
+    if ('close' in result) {
+        throw new Error('Incorrect build output, got watcher');
+    }
+    const outputs = (Array.isArray(result) ? result : [result]).flatMap(({ output }) => output);
+    const bundledIndex = outputs.find((output) => output.type === 'chunk' && output.isEntry && output.name === 'index');
+    if (!bundledIndex || bundledIndex.type !== 'chunk') {
+        throw new Error('Unexpected build output, no bundled index found');
+    }
+    if (!bundledIndex.exports.includes('handler')) {
+        throw new Error('Unexpected build output, no `handler` export found');
+    }
+}

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

@@ -1,16 +1,18 @@
 import {existsSync, statSync} from 'node:fs'
-import {join} from 'node:path'
+import {isAbsolute, join} from 'node:path'
 import process from 'node:process'
 
 export function getFunctionSource(src) {
-  if (statSync(src).isDirectory()) {
-    const indexPath = join(src, 'index.js')
+  const pathToCheck = isAbsolute(src) ? src : join(process.cwd(), src)
+
+  if (statSync(pathToCheck).isDirectory()) {
+    const indexPath = join(pathToCheck, 'index.js')
     if (!existsSync(indexPath)) {
-      throw Error(`Function directory ${src} has no index.js`)
+      throw Error(`Function directory ${pathToCheck} has no index.js`)
     }
     return indexPath
   }
-  return src
+  return pathToCheck
 }
 
 // Start when payload data arrives from parent process
@@ -28,7 +30,7 @@ process.on('message', async (data) => {
   let json = null
 
   // Import the function code
-  const {handler} = await import(getFunctionSource(join(process.cwd(), srcPath)))
+  const {handler} = await import(getFunctionSource(srcPath))
 
   // backup stdout
   const originalStdoutWrite = process.stdout.write.bind(process.stdout)

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

@@ -6,10 +6,10 @@ export function formatTitle(title, name) {
 }
 export function formatResourceTree(resources) {
     if (!resources || resources.length === 0) {
-        return '  Zero resources in this stack';
+        return '  Zero deployed resources';
     }
     const output = [];
-    output.push(`${blue('Stack Resources')} [${resources.length}]`);
+    output.push(`${blue('Blueprint Resources')} [${resources.length}]`);
     const functionResources = resources.filter((r) => r.type?.startsWith('sanity.function.'));
     const otherResources = resources.filter((r) => !r.type?.startsWith('sanity.function.'));
     const hasOtherResources = otherResources.length > 0;

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

@@ -0,0 +1,4 @@
+import type { BlueprintIssue } from '../../actions/blueprints/index.js';
+import type { BlueprintParserError } from '../types.js';
+export declare function presentBlueprintIssues(issues: BlueprintIssue[]): string;
+export declare function presentBlueprintParserErrors(errors: BlueprintParserError[]): string;

package/dist/utils/display/errors.js

@@ -0,0 +1,27 @@
+export function presentBlueprintIssues(issues) {
+    const report = [];
+    for (const issue of issues) {
+        switch (issue.code) {
+            case 'PARSE_ERROR':
+                report.push(issue.message);
+                if (issue.errors)
+                    report.push(presentBlueprintParserErrors(issue.errors));
+                break;
+            case 'NO_STACK_ID':
+                report.push('Existing deployment not found.');
+                break;
+            case 'NO_PROJECT_ID':
+                report.push('Project ID not found.');
+                break;
+            case 'NO_STACK':
+                report.push('Existing deployment not found.');
+                break;
+            default:
+                report.push(issue.message);
+        }
+    }
+    return report.join('\n');
+}
+export function presentBlueprintParserErrors(errors) {
+    return errors.map((e) => e.message).join('\n');
+}

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

@@ -2,3 +2,4 @@ export * as blueprintsFormatting from './blueprints-formatting.js';
 export * as colors from './colors.js';
 export * as dates from './dates.js';
 export * as logsFormatting from './logs-formatting.js';
+export * as errors from './errors.js';

package/dist/utils/display/index.js

@@ -2,3 +2,4 @@ export * as blueprintsFormatting from './blueprints-formatting.js';
 export * as colors from './colors.js';
 export * as dates from './dates.js';
 export * as logsFormatting from './logs-formatting.js';
+export * as errors from './errors.js';

package/dist/utils/functions/find-entry-point.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolves the source path to an executable entry file path.
+ *
+ * If the source path is a directory, it looks for `package.json#main`, then `index.ts`, then `index.js`.
+ *
+ * @param srcPath - The source path (can be a file or directory).
+ * @param displayName - Optional display name for the function, used in error messages.
+ * @returns The absolute path to the entry file.
+ * @throws If the entry file cannot be determined.
+ */
+export declare function findFunctionEntryPoint(srcPath: string, displayName?: string): Promise<string>;

package/dist/utils/functions/find-entry-point.js

@@ -0,0 +1,75 @@
+import { readFile, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { cwd } from 'node:process';
+/**
+ * Resolves the source path to an executable entry file path.
+ *
+ * If the source path is a directory, it looks for `package.json#main`, then `index.ts`, then `index.js`.
+ *
+ * @param srcPath - The source path (can be a file or directory).
+ * @param displayName - Optional display name for the function, used in error messages.
+ * @returns The absolute path to the entry file.
+ * @throws If the entry file cannot be determined.
+ */
+export async function findFunctionEntryPoint(srcPath, displayName) {
+    const absolutePath = resolve(cwd(), srcPath);
+    let stats;
+    try {
+        stats = await stat(absolutePath);
+    }
+    catch (err) {
+        throw new Error(`Source path not found or inaccessible: ${srcPath}`, { cause: err });
+    }
+    if (stats.isFile()) {
+        // It's already an entry file path
+        return absolutePath;
+    }
+    if (stats.isDirectory()) {
+        // 1. Check package.json#main
+        try {
+            const pkgJsonPath = join(absolutePath, 'package.json');
+            const pkgJsonContent = await readFile(pkgJsonPath, 'utf8');
+            const pkgJson = JSON.parse(pkgJsonContent);
+            if (pkgJson.main) {
+                const mainPath = resolve(absolutePath, pkgJson.main);
+                if (await fileExists(mainPath)) {
+                    return mainPath;
+                }
+                // If pkgJson.main points to a non-existent file, we continue checking index files
+            }
+        }
+        catch {
+            // Ignore errors (missing package.json, invalid JSON, etc.)
+            // Consider warning the user on invalid JSON though?
+        }
+        // 2. Check index.ts
+        const indexTs = join(absolutePath, 'index.ts');
+        if (await fileExists(indexTs)) {
+            return indexTs;
+        }
+        // 3. Check index.js
+        const indexJs = join(absolutePath, 'index.js');
+        if (await fileExists(indexJs)) {
+            return indexJs;
+        }
+        const nameHint = displayName ? ` for function "${displayName}"` : '';
+        throw new Error(`Could not determine entry file${nameHint} in directory: ${srcPath}. Looked for package.json#main, index.ts, index.js.`);
+    }
+    // Should not happen if stat succeeded, but defensively handle
+    throw new Error(`Source path is neither a file nor a directory: ${srcPath}`);
+}
+/**
+ * Checks if a file exists and is a file.
+ */
+async function fileExists(filePath) {
+    try {
+        const stats = await stat(filePath);
+        return stats.isFile();
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+            return false;
+        }
+        throw err; // Re-throw other errors
+    }
+}

package/dist/utils/functions/should-bundle.d.ts

@@ -0,0 +1,2 @@
+import type { LocalFunctionResource } from '../types.js';
+export declare function shouldBundleFunction(resource: LocalFunctionResource): Promise<boolean>;

package/dist/utils/functions/should-bundle.js

@@ -0,0 +1,23 @@
+import { findFunctionEntryPoint } from './find-entry-point.js';
+export async function shouldBundleFunction(resource) {
+    // 1. Explicit configuration takes precedence
+    if (typeof resource.bundle === 'boolean') {
+        return resource.bundle;
+    }
+    if (!resource.src) {
+        // Cannot determine without a source path
+        return false;
+    }
+    try {
+        // 2. Find the actual entry point
+        const entryPoint = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+        // 3. Check if the resolved entry point is a TypeScript file
+        return entryPoint.endsWith('.ts');
+    }
+    catch (err) {
+        // If we cannot find the entry point, we cannot determine if it's TS.
+        // Log a warning and default to false (don't bundle).
+        console.warn(`[warn] Could not determine entry point for function "${resource.displayName ?? resource.name}" while checking if bundling is needed: ${err instanceof Error ? err.message : err}`);
+        return false;
+    }
+}

package/dist/utils/invoke-local.d.ts

@@ -1,3 +1,3 @@
-import type { InvocationResponse, InvokeContextOptions } from './types.js';
+import type { InvocationResponse, InvokeContextOptions, LocalFunctionResource } from './types.js';
 export declare function sanitizeLogs(logs: string): string;
-export default function invoke(srcPath: string, data: null | object, context: InvokeContextOptions, timeout?: number): Promise<InvocationResponse>;
+export default function invoke(resource: LocalFunctionResource, data: Record<string, unknown> | null, context: InvokeContextOptions, timeout?: number): Promise<InvocationResponse>;

package/dist/utils/invoke-local.js

@@ -1,42 +1,80 @@
 import { spawn } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
 import { cwd } from 'node:process';
 import { setTimeout } from 'node:timers';
 import config from '../config.js';
+import { bundleFunction } from './bundle/bundle-function.js';
+import { findFunctionEntryPoint } from './functions/find-entry-point.js';
+import { shouldBundleFunction } from './functions/should-bundle.js';
 function getChildProcessWrapperPath() {
     return new URL('./child-process-wrapper.js', import.meta.url).pathname;
 }
 export function sanitizeLogs(logs) {
     return logs.replace(/([a-zA-Z0-9]{10})[a-zA-Z0-9]{65,}/g, '$1**********');
 }
-export default async function invoke(srcPath, data, context, timeout = 5) {
+export default async function invoke(resource, data, context, timeout = 5) {
+    if (!resource.src) {
+        throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
+    }
+    let cleanupBundle = async () => { };
+    let functionPath = '';
+    let bundleTimings = undefined;
+    if (await shouldBundleFunction(resource)) {
+        const bundleResult = await bundleFunction(resource);
+        functionPath = await findFunctionEntryPoint(bundleResult.outputDir);
+        bundleTimings = bundleResult.timings;
+        cleanupBundle = bundleResult.cleanup;
+    }
+    else {
+        functionPath = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+    }
     return new Promise((resolve, reject) => {
         let child;
         let timer;
+        let executionStart;
         function start() {
-            child = spawn('node', [getChildProcessWrapperPath()], {
+            executionStart = performance.now();
+            child = spawn('node', ['--enable-source-maps', getChildProcessWrapperPath()], {
                 cwd: cwd(),
                 stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
             });
-            // Note: start a timeout so child process doesn't run forever
             child.on('message', (data) => {
+                const executionTimeMs = performance.now() - executionStart;
                 const { json, logs } = JSON.parse(data.toString());
                 shutdown();
-                resolve({ json, logs: sanitizeLogs(logs), error: '' });
+                resolve({
+                    json,
+                    logs: sanitizeLogs(logs),
+                    error: undefined,
+                    timings: {
+                        ...bundleTimings,
+                        execute: executionTimeMs,
+                    },
+                });
             });
             child.on('error', (error) => {
+                shutdown();
                 reject(new Error(`encountered error ${error.message}`));
             });
             child.on('exit', (code) => {
+                const executionTimeMs = performance.now() - executionStart;
                 shutdown();
                 if (code !== 0) {
                     reject(new Error(`exited with code ${code}`));
                 }
                 else {
-                    resolve({ json: {}, logs: '', error: '' });
+                    resolve({
+                        json: {},
+                        logs: '',
+                        error: undefined,
+                        timings: {
+                            ...bundleTimings,
+                            execute: executionTimeMs,
+                        },
+                    });
                 }
             });
             timer = setTimeout(() => {
-                // timedOut = true
                 shutdown();
                 reject(new Error(`Timed out after hitting its ${timeout}s timeout!`));
             }, timeout * 1000);
@@ -51,11 +89,14 @@ export default async function invoke(srcPath, data, context, timeout = 5) {
                     },
                 },
             };
-            child.send(JSON.stringify({ srcPath, payload }, null, 2));
+            child.send(JSON.stringify({ srcPath: functionPath, payload }, null, 2));
         }
         function shutdown() {
             clearTimeout(timer);
-            child.kill();
+            if (child && !child.killed) {
+                child.kill();
+            }
+            cleanupBundle().catch((err) => console.warn('Bundle cleanup failed:', err));
         }
         start();
     });

package/dist/utils/is-record.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/utils/is-record.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/utils/parse-json-object.d.ts

@@ -0,0 +1 @@
+export declare function parseJsonObject(jsonString: string): null | Record<string, unknown>;

package/dist/utils/parse-json-object.js

@@ -0,0 +1,10 @@
+import { isRecord } from './is-record.js';
+export function parseJsonObject(jsonString) {
+    try {
+        const o = JSON.parse(jsonString);
+        return isRecord(o) ? o : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/types.d.ts

@@ -12,7 +12,7 @@ export interface LocalBlueprint {
     /** @link https://github.com/sanity-io/blueprints-rfc/blob/main/readme.md#outputs */
     outputs?: Array<Record<string, unknown>>;
     /** @link https://github.com/sanity-io/blueprints-rfc/blob/main/readme.md#resources */
-    resources?: Array<LocalResource>;
+    resources?: Array<LocalResource | LocalFunctionResource>;
     /** @link https://github.com/sanity-io/blueprints-rfc/blob/main/readme.md#parameters */
     parameters?: Array<{
         name: string;
@@ -51,6 +51,7 @@ export declare function isLocalFunctionResource(r: LocalResource): r is LocalFun
 /** @internal */
 export interface LocalFunctionResource extends LocalResource {
     src?: string;
+    bundle?: boolean;
     memory?: number;
     timeout?: number;
     env?: Record<string, string>;
@@ -95,6 +96,7 @@ export interface StackPayload {
     name: string;
     projectId: string;
     document: LocalBlueprint;
+    useProjectBasedId?: boolean;
 }
 /** @internal */
 export interface InvokePayloadOptions {
@@ -115,6 +117,7 @@ export interface InvocationResponse {
     error: undefined | unknown;
     json: object | undefined;
     logs: string | undefined;
+    timings?: Record<string, number>;
 }
 /** @internal */
 export interface BlueprintLog {
@@ -133,10 +136,16 @@ export interface FunctionLog {
 }
 /** @internal */
 export declare enum BlueprintParserErrorType {
-    MissingProject = "missing_project",
-    MissingStack = "missing_stack",
     InvalidProperty = "invalid_property",
-    InvalidStack = "invalid_stack"
+    InvalidVersion = "invalid_version",
+    InvalidType = "invalid_type",
+    MissingRequiredProperty = "missing_required_property",
+    DuplicateName = "duplicate_name",
+    InvalidFormat = "invalid_format",
+    InvalidValue = "invalid_value",
+    JsonValidationError = "json_validation_error",
+    InvalidInput = "invalid_input",
+    MissingParameter = "missing_parameter"
 }
 /** @internal */
 export interface BlueprintParserError {

package/dist/utils/types.js

@@ -4,8 +4,14 @@ export function isLocalFunctionResource(r) {
 /** @internal */
 export var BlueprintParserErrorType;
 (function (BlueprintParserErrorType) {
-    BlueprintParserErrorType["MissingProject"] = "missing_project";
-    BlueprintParserErrorType["MissingStack"] = "missing_stack";
     BlueprintParserErrorType["InvalidProperty"] = "invalid_property";
-    BlueprintParserErrorType["InvalidStack"] = "invalid_stack";
+    BlueprintParserErrorType["InvalidVersion"] = "invalid_version";
+    BlueprintParserErrorType["InvalidType"] = "invalid_type";
+    BlueprintParserErrorType["MissingRequiredProperty"] = "missing_required_property";
+    BlueprintParserErrorType["DuplicateName"] = "duplicate_name";
+    BlueprintParserErrorType["InvalidFormat"] = "invalid_format";
+    BlueprintParserErrorType["InvalidValue"] = "invalid_value";
+    BlueprintParserErrorType["JsonValidationError"] = "json_validation_error";
+    BlueprintParserErrorType["InvalidInput"] = "invalid_input";
+    BlueprintParserErrorType["MissingParameter"] = "missing_parameter";
 })(BlueprintParserErrorType || (BlueprintParserErrorType = {}));