@sanity/runtime-cli 4.3.3 → 4.3.5-bundle.0

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/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() {
+            executionStart = performance.now();
             child = spawn('node', [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>;
@@ -115,6 +116,7 @@ export interface InvocationResponse {
     error: undefined | unknown;
     json: object | undefined;
     logs: string | undefined;
+    timings?: Record<string, number>;
 }
 /** @internal */
 export interface BlueprintLog {

package/oclif.manifest.json

@@ -769,5 +769,5 @@
       ]
     }
   },
-  "version": "4.3.3"
+  "version": "4.3.5-bundle.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "4.3.3",
+  "version": "4.3.5-bundle.0",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -47,6 +47,7 @@
     "postbuild": "oclif manifest && oclif readme",
     "build:ts": "shx rm -rf dist *.tsbuildinfo && tsc -b",
     "build:static": "npm run copy:wrapper && npm run copy:server",
+    "clean": "shx rm -rf dist oclif.manifest.json",
     "copy:server": "shx cp -r ./src/server/static ./dist/server",
     "copy:wrapper": "shx cp ./src/utils/child-process-wrapper.js ./dist/utils/child-process-wrapper.js",
     "lint": "biome ci",
@@ -68,6 +69,8 @@
     "eventsource": "^3.0.6",
     "inquirer": "^12.5.2",
     "mime-types": "^3.0.1",
+    "vite": "^6.3.3",
+    "vite-tsconfig-paths": "^5.1.4",
     "xdg-basedir": "^5.1.0",
     "yocto-spinner": "^0.2.1"
   },

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

@@ -1 +0,0 @@
-export default function isJson(jsonString: string): null | object;

package/dist/utils/is-json.js

@@ -1,12 +0,0 @@
-export default function isJson(jsonString) {
-    try {
-        const o = JSON.parse(jsonString);
-        if (o && typeof o === 'object') {
-            return o;
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}