@sanity/runtime-cli 17.0.0 → 17.1.0-next.gcfbd613

package/dist/utils/functions/invoke-local.js

@@ -1,185 +0,0 @@
-import { spawn } from 'node:child_process';
-import { performance } from 'node:perf_hooks';
-import { cwd } from 'node:process';
-import { setTimeout } from 'node:timers';
-import { fileURLToPath } from 'node:url';
-import * as groq from 'groq-js';
-import config from '../../config.js';
-import { groupBlueprintResources } from '../blueprints/group-resources.js';
-import { isGroqContextOptions, } from '../types.js';
-import { findFunctionEntryPoint } from './find-entry-point.js';
-import { cleanupTempPackageJson, createTempPackageJson, doesPackageJsonExists, } from './package-json.js';
-import { resolveResourceDependencies } from './resolve-dependencies.js';
-import { shouldAutoResolveDependencies } from './should-auto-resolve-deps.js';
-import { shouldTranspileFunction } from './should-transpile.js';
-import { transpileFunction } from './transpile/function.js';
-function getChildProcessWrapperPath() {
-    return fileURLToPath(new URL('./child-process-wrapper.js', import.meta.url));
-}
-export function sanitizeLogs(logs) {
-    return logs.replace(/([a-zA-Z0-9]{10})[a-zA-Z0-9]{65,}/g, '$1**********');
-}
-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;
-    // default groq rule is: gimme full doc content. otherwise, parse + eval custom rule
-    // applying the GROQ filter may result in a slimmer set of documents
-    if (resource.event.filter || resource.event.projection) {
-        const query = `*[${resource.event.filter || ''}]${resource.event.projection || ''}`;
-        try {
-            const rule = groq.parse(query, { mode: 'delta' });
-            const sanity = projectId && dataset ? { projectId, dataset } : undefined;
-            const queryResults = await groq.evaluate(rule, { dataset: [data], before, after, sanity });
-            const currentFunctionDocumentSet = await queryResults.get();
-            return currentFunctionDocumentSet[0];
-        }
-        catch (groqErr) {
-            const detail = groqErr instanceof Error && `; ${groqErr.message}`;
-            throw new Error(`Invalid rule configuration: ${query}${detail}`, { cause: groqErr });
-        }
-    }
-    // default groq rule so just return the data
-    return data;
-}
-export default async function invoke(resource, payload, context, options) {
-    if (!resource.src) {
-        throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
-    }
-    let cleanupBundle = async () => { };
-    let functionPath = '';
-    let bundleTimings;
-    // If no package.json exists we will create a temporary one to avoid the
-    // Module Type warning from node
-    const existingPackageJson = doesPackageJsonExists(resource);
-    const shouldTranspile = await shouldTranspileFunction(resource);
-    if (shouldTranspile) {
-        const transpileResult = await transpileFunction(resource);
-        functionPath = await findFunctionEntryPoint(transpileResult.outputDir);
-        bundleTimings = transpileResult.timings;
-        cleanupBundle = transpileResult.cleanup;
-    }
-    else {
-        functionPath = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
-    }
-    const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
-    if (shouldResolveDependencies && existingPackageJson) {
-        await resolveResourceDependencies(resource, { transpiled: shouldTranspile });
-    }
-    if (!existingPackageJson) {
-        createTempPackageJson(functionPath);
-    }
-    const { forceColor = true, timeout = 10 } = options;
-    let filteredData = payload?.payload?.data || {};
-    if (resource.type === 'sanity.function.document' ||
-        resource.type === 'sanity.function.media-library.asset') {
-        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;
-        let executionStart;
-        function start() {
-            executionStart = performance.now();
-            child = spawn('node', ['--enable-source-maps', getChildProcessWrapperPath()], {
-                cwd: cwd(),
-                stdio: ['pipe', 'pipe', 'pipe', 'ipc'], // changed: use 'pipe' so we can capture output
-                env: { ...process.env, ...resource.env, FORCE_COLOR: forceColor ? '1' : '0' },
-            });
-            // NEW: capture stdout and stderr
-            let stdout = '';
-            let stderr = '';
-            child.stdout?.on('data', (data) => {
-                stdout += data.toString();
-            });
-            child.stderr?.on('data', (data) => {
-                stderr += data.toString();
-            });
-            child.on('message', (data) => {
-                const executionTimeMs = performance.now() - executionStart;
-                const { json, logs, error } = JSON.parse(data.toString());
-                shutdown();
-                resolve({
-                    json,
-                    logs: sanitizeLogs(logs),
-                    error,
-                    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) {
-                    // use captured stderr if available
-                    const message = stderr.trim().length > 0
-                        ? `Process failed with code ${code}\n${stderr}`
-                        : `exited with code ${code}`;
-                    reject(new Error(message));
-                }
-                else {
-                    resolve({
-                        json: undefined,
-                        logs: sanitizeLogs(stdout),
-                        error: undefined,
-                        timings: {
-                            ...bundleTimings,
-                            execute: executionTimeMs,
-                        },
-                    });
-                }
-            });
-            timer = setTimeout(() => {
-                shutdown();
-                reject(new Error(`Timeout: Function exceeded the ${timeout}-second time limit.`));
-            }, timeout * 1000);
-            const payload = {
-                data: { ...filteredData },
-                context: {
-                    ...context,
-                    local: true,
-                    resources: groupBlueprintResources(context.resources ?? []),
-                    ...(isGroqContextOptions(context) && {
-                        clientOptions: {
-                            ...context.clientOptions,
-                            apiHost: config.apiUrl,
-                        },
-                    }),
-                },
-            };
-            child.send(JSON.stringify({ srcPath: functionPath, payload }, null, 2));
-        }
-        function shutdown() {
-            clearTimeout(timer);
-            if (child && !child.killed) {
-                child.kill();
-            }
-            // If we previously created a temporary package.json, let's clean it up
-            if (!existingPackageJson) {
-                cleanupTempPackageJson(functionPath);
-            }
-            cleanupBundle().catch((err) => console.warn('Bundle cleanup failed:', err));
-        }
-        start();
-    });
-}