@sanity/runtime-cli 17.1.0 → 17.2.0-blueprinit.g62f8017

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

@@ -3,18 +3,17 @@ 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, installer, }) {
-    const rawArc = await convertResourceToArcFormat(resource, transpiled);
-    const inv = await inventory({ rawArc });
-    const cwd = inv.inv._project.cwd;
+export async function resolveResourceDependencies({ resource, transpiled, blueprintFileDir, functionPath, installer, }) {
+    const rawArc = await convertResourceToArcFormat(resource, functionPath, transpiled);
+    const inv = await inventory({ rawArc, cwd: blueprintFileDir });
     let installType = 'npm';
     if (installer) {
         installType = installer;
     }
-    else if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
+    else if (existsSync(join(blueprintFileDir, 'pnpm-lock.yaml'))) {
         installType = 'pnpm';
     }
-    else if (existsSync(join(cwd, 'yarn.lock'))) {
+    else if (existsSync(join(blueprintFileDir, 'yarn.lock'))) {
         installType = 'yarn';
     }
     try {

package/dist/utils/functions/resource-to-arc.d.ts

@@ -1,2 +1,2 @@
 import type { FunctionResource } from '../types.js';
-export declare function convertResourceToArcFormat(resource: FunctionResource, transpiled: boolean): Promise<string>;
+export declare function convertResourceToArcFormat(resource: FunctionResource, functionPath: string, transpiled: boolean): Promise<string>;

package/dist/utils/functions/resource-to-arc.js

@@ -1,16 +1,15 @@
 import { stat } from 'node:fs/promises';
-import { resolve, sep } from 'node:path';
-import { cwd } from 'node:process';
-export async function convertResourceToArcFormat(resource, transpiled) {
+import { sep } from 'node:path';
+export async function convertResourceToArcFormat(resource, functionPath, transpiled) {
     if (!resource.src) {
         throw Error('Missing `resource.src` property');
     }
     // Get stats from file
-    const stats = await stat(resolve(cwd(), resource.src));
+    const stats = await stat(functionPath);
     // Convert resource.src to arc file path format
     const srcPath = resource.src?.split(sep).join('/');
     const entryDir = stats.isFile() ? srcPath.substring(0, srcPath.lastIndexOf('/')) : srcPath;
-    const functionPath = transpiled ? `${entryDir}/.build/function-${resource.name}` : entryDir;
+    functionPath = transpiled ? `${entryDir}/.build/function-${resource.name}` : entryDir;
     return `@app
 hydrate-function
 

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

@@ -1,2 +1,8 @@
 import type { FunctionResource } from '../types.js';
-export declare function shouldTranspileFunction(resource: FunctionResource): Promise<boolean>;
+export type ShouldTranspileResult = {
+    transpile: true;
+    entryPoint: string;
+} | {
+    transpile: false;
+};
+export declare function shouldTranspileFunction(resource: FunctionResource, functionPath: string): Promise<ShouldTranspileResult>;

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

@@ -1,22 +1,22 @@
 import { findFunctionEntryPoint } from './find-entry-point.js';
-export async function shouldTranspileFunction(resource) {
-    if ('transpile' in resource && typeof resource.transpile === 'boolean') {
-        return resource.transpile;
-    }
-    if (!resource.src) {
-        // Cannot determine without a source path
-        return false;
+export async function shouldTranspileFunction(resource, functionPath) {
+    const hasTranspile = 'transpile' in resource && typeof resource.transpile === 'boolean';
+    if (!functionPath || (hasTranspile && resource.transpile === false)) {
+        return { transpile: false };
     }
     try {
         // 2. Find the actual entry point
-        const entryPoint = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+        const entryPoint = await findFunctionEntryPoint(functionPath, resource.displayName ?? resource.name);
         // 3. Check if the resolved entry point is a TypeScript file
-        return entryPoint.endsWith('.ts');
+        return {
+            entryPoint,
+            transpile: hasTranspile ? resource.transpile === true : 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 transpiling is needed: ${err instanceof Error ? err.message : err}`);
-        return false;
+        return { transpile: false };
     }
 }

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

@@ -1,6 +1,9 @@
 import type { FunctionResource, InstallerType } from '../../types.js';
 export declare const resolveViteRoot: (entry: string) => string;
-export declare function transpileFunction(resource: FunctionResource, { installer }?: {
+export declare function transpileFunction({ resource, functionPath, entryPoint, installer, }: {
+    resource: FunctionResource;
+    functionPath: string;
+    entryPoint: string;
     installer?: InstallerType;
 }): Promise<{
     type: string;

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

@@ -3,9 +3,9 @@ import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { cwd } from 'node:process';
 import * as find from 'empathic/find';
+import stripAnsi from 'strip-ansi';
 import { build as viteBuild } from 'vite';
 import { detectNativeModulesPlugin } from '../detect-native-modules.js';
-import { findFunctionEntryPoint } from '../find-entry-point.js';
 import { cleanupSourceMaps } from './cleanup-source-maps.js';
 import { createPnpmRequire } from './pnpm.js';
 import { verifyHandler } from './verify-handler.js';
@@ -13,23 +13,18 @@ export const resolveViteRoot = (entry) => {
     const nodeModulesDir = find.dir('node_modules', { cwd: entry });
     return nodeModulesDir ? path.dirname(nodeModulesDir) : entry;
 };
-export async function transpileFunction(resource, { installer } = {}) {
+export async function transpileFunction({ resource, functionPath, entryPoint, installer, }) {
     if (!resource.src)
         throw new Error('Resource src is required');
     if (!resource.name)
         throw new Error('Resource name is required');
     const timings = {};
     const transpileStart = performance.now();
-    const sourcePath = path.resolve(cwd(), resource.src);
-    const stats = await stat(sourcePath);
-    const fnDisplayName = resource.displayName ?? resource.name;
-    const findEntryStart = performance.now();
-    const entry = await findFunctionEntryPoint(sourcePath, fnDisplayName);
-    timings['transpile:findEntry'] = performance.now() - findEntryStart;
-    const entryDir = stats.isFile() ? path.dirname(sourcePath) : sourcePath;
+    const stats = await stat(functionPath);
+    const entryDir = stats.isFile() ? path.dirname(functionPath) : functionPath;
     const outputPathStart = performance.now();
     const outputDir = await getTranspileOutputPath(entryDir, resource.name);
-    const outputFile = path.join(outputDir, getOutputFilename(entry));
+    const outputFile = path.join(outputDir, getOutputFilename(entryPoint));
     const fnRootDir = resolveViteRoot(entryDir);
     timings['transpile:setupOutput'] = performance.now() - outputPathStart;
     async function cleanupTmpDir() {
@@ -51,10 +46,10 @@ export async function transpileFunction(resource, { installer } = {}) {
                 sourcemap: true,
                 ssr: true,
                 rolldownOptions: {
-                    input: entry,
+                    input: entryPoint,
                     output: {
                         format: 'esm',
-                        entryFileNames: getOutputFilename(entry),
+                        entryFileNames: getOutputFilename(entryPoint),
                         ...(bundle
                             ? {}
                             : {
@@ -86,7 +81,7 @@ export async function transpileFunction(resource, { installer } = {}) {
         await writeTranspiledPackageJson(entryDir, outputFile);
         timings['transpile:writePackage'] = performance.now() - pkgStart;
         const cleanupStart = performance.now();
-        await cleanupSourceMaps(sourcePath, outputDir);
+        await cleanupSourceMaps(functionPath, outputDir);
         timings['transpile:cleanupMaps'] = performance.now() - cleanupStart;
         timings.bundle = performance.now() - transpileStart;
         return {
@@ -100,7 +95,7 @@ export async function transpileFunction(resource, { installer } = {}) {
     }
     catch (err) {
         await cleanupTmpDir();
-        throw new Error(`Transpiling of function failed: ${formatBuildError(err)}`, {
+        throw new Error(`Transpiling of function failed: ${stripAnsi(formatBuildError(err))}`, {
             cause: err,
         });
     }

package/dist/utils/functions/transpile/verify-handler.js

@@ -4,7 +4,7 @@ export async function verifyHandler(result) {
     }
     const outputs = (Array.isArray(result) ? result : [result]).flatMap(({ output }) => output);
     const bundledIndex = outputs.find((output) => output.type === 'chunk' && output.isEntry && output.fileName === 'index.js');
-    if (!bundledIndex || bundledIndex.type !== 'chunk') {
+    if (bundledIndex?.type !== 'chunk') {
         throw new Error('Unexpected build output, no bundled index found');
     }
     if (!bundledIndex.exports.includes('handler')) {

package/dist/utils/logger.d.ts

@@ -6,11 +6,13 @@ export declare function Logger(log: (msg: string) => void, flags?: {
 }): {
     (msg: string): void;
     isTraceEnabled: boolean;
-    trace(formatter: unknown, ...args: unknown[]): false | void;
-    verbose(formatter: unknown, ...args: unknown[]): false | void;
-    info(formatter: unknown, ...args: unknown[]): false | void;
-    warn(formatter: unknown, ...args: unknown[]): false | void;
-    error(formatter: unknown, ...args: unknown[]): false | void;
+    trace: (formatter: unknown, ...args: unknown[]) => void | false;
+    verbose: (formatter: unknown, ...args: unknown[]) => void | false;
+    info: (formatter: unknown, ...args: unknown[]) => void | false;
+    warn: (formatter: unknown, ...args: unknown[]) => void | false;
+    error: (formatter: unknown, ...args: unknown[]) => void | false;
+    showProgress: (percent?: number) => void;
+    clearProgress: () => void;
     ora: typeof ora;
 };
 export type Logger = ReturnType<typeof Logger>;

package/dist/utils/logger.js

@@ -1,5 +1,6 @@
 import { format } from 'node:util';
 import ora from 'ora';
+import { clearProgress, showBusy, showError, showProgress } from './progress.js';
 var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
@@ -19,16 +20,47 @@ export function Logger(log, flags = {}) {
     logger.info = (formatter, ...args) => level <= LogLevel.INFO && logger(format(formatter, ...args));
     logger.warn = (formatter, ...args) => level <= LogLevel.WARN && logger(format(formatter, ...args));
     logger.error = (formatter, ...args) => level <= LogLevel.ERROR && logger(format(formatter, ...args));
+    logger.showProgress = (percent) => {
+        if (flags.json)
+            return;
+        if (percent === undefined)
+            showBusy();
+        else
+            showProgress(percent);
+    };
+    logger.clearProgress = () => {
+        if (flags.json)
+            return;
+        clearProgress();
+    };
     const oraWrapper = (opts) => {
         if (flags.json)
             return createOraLineLoggingWrapper(opts, logger);
         if (level >= LogLevel.INFO)
-            return ora(opts);
+            return withTerminalProgress(ora(opts));
         return createOraLineLoggingWrapper(opts, logger);
     };
     logger.ora = oraWrapper;
     return logger;
 }
+function withTerminalProgress(spinner) {
+    const wrap = (name, effect) => {
+        if (typeof spinner[name] !== 'function')
+            return;
+        const original = spinner[name].bind(spinner);
+        spinner[name] = (...args) => {
+            const result = original(...args);
+            effect();
+            return result;
+        };
+    };
+    wrap('start', showBusy);
+    wrap('fail', showError);
+    for (const name of ['stop', 'succeed', 'warn', 'info', 'stopAndPersist']) {
+        wrap(name, clearProgress);
+    }
+    return spinner;
+}
 /**
  * An ora-like wrapper that uses standard line output logging instead of rendering a spinner; used in verbose and trace modes.
  */

package/dist/utils/progress.d.ts

@@ -0,0 +1,5 @@
+export declare function showProgress(percent: number): void;
+export declare function showBusy(): void;
+export declare function showError(): void;
+export declare function showPaused(percent: number): void;
+export declare function clearProgress(): void;

package/dist/utils/progress.js

@@ -0,0 +1,40 @@
+import { stderr } from 'node:process';
+import { onExit } from 'signal-exit';
+const ST = '\x1b\\';
+const STATES = {
+    clear: 0,
+    normal: 1,
+    error: 2,
+    paused: 4,
+    busy: 3,
+};
+let exitHookRegistered = false;
+function write(state, value = 0) {
+    if (!stderr.isTTY)
+        return;
+    if (!exitHookRegistered) {
+        exitHookRegistered = true;
+        function clear() {
+            stderr.write(`\x1b]9;4;0;0${ST}`);
+        }
+        // arc/utils SIGINT handler clobbers our signal-exit; luckily it then calls process.exit()
+        process.once('exit', clear); // triggered by arc/utils SIGINT handler
+        onExit(clear); // triggered by all other exit paths
+    }
+    stderr.write(`\x1b]9;4;${STATES[state]};${Math.round(value)}${ST}`);
+}
+export function showProgress(percent) {
+    write('normal', Math.max(0, Math.min(100, percent)));
+}
+export function showBusy() {
+    write('busy');
+}
+export function showError() {
+    write('error', 100);
+}
+export function showPaused(percent) {
+    write('paused', Math.max(0, Math.min(100, percent)));
+}
+export function clearProgress() {
+    write('clear');
+}

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

@@ -0,0 +1,6 @@
+import type { BlueprintStudioResource } from '@sanity/blueprints';
+import type { AssetPrepResult } from '../types.js';
+export declare function prepareStudioAsset({ blueprintFileDir, resource, }: {
+    blueprintFileDir: string;
+    resource: BlueprintStudioResource;
+}): Promise<AssetPrepResult>;

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

@@ -0,0 +1,139 @@
+import { createWriteStream } from 'node:fs';
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path, { basename, dirname, join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { createGzip } from 'node:zlib';
+import { buildStudio, compareDependencyVersions } from '@sanity/cli-build/_internal/build';
+import { pack } from 'tar-fs';
+export async function prepareStudioAsset({ blueprintFileDir, resource, }) {
+    // validate resource has an externalId
+    if (!('externalId' in resource) ||
+        typeof resource.externalId !== 'string' ||
+        !resource.externalId) {
+        return {
+            success: false,
+            async cleanup() {
+                // no op
+            },
+            error: `Unable to determine appId for sanity.studio resource '${resource.name}'`,
+        };
+    }
+    let cleanup = async () => {
+        // no op
+    };
+    const studioPath = path.resolve(blueprintFileDir, resource.src);
+    try {
+        const studioPathStat = await stat(studioPath);
+        if (!studioPathStat.isDirectory()) {
+            return {
+                success: false,
+                cleanup,
+                error: `Property 'src' on resource with type '${resource.type}' must be a directory`,
+            };
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            cleanup,
+            error: `Unable to read given 'src' on resource with type '${resource.type}': ${msg}`,
+        };
+    }
+    try {
+        const outDir = await mkdtemp(join(tmpdir(), `studio-build-`));
+        const outFile = `${outDir}.tar.gz`;
+        cleanup = async () => {
+            await rm(outDir, { force: true, recursive: true });
+            await rm(outFile, { force: true });
+        };
+        const appId = resource.externalId;
+        try {
+            await buildStudio({
+                appId,
+                autoUpdatesEnabled: resource.autoUpdates.enabled,
+                checkAppId() { },
+                async compareDependencyVersions(packages) {
+                    return compareDependencyVersions(packages, studioPath, { appId });
+                },
+                determineBasePath() {
+                    return resource.basePath ?? '/';
+                },
+                isApp: false,
+                isWorkbenchApp: false,
+                minify: resource.minify ?? true,
+                outDir,
+                output: createSilentOutput(),
+                reactCompiler: resource.reactCompiler || false,
+                schemaExtraction: undefined,
+                sourceMap: resource.sourceMap ?? false,
+                stats: false,
+                unattendedMode: true,
+                // TODO pass in vite config from the studio resource
+                vite: undefined,
+                workDir: studioPath,
+                eventListener: {
+                    onBuildFail({ message }) {
+                        throw new Error(message);
+                    },
+                    onInvalidStyledComponentsVersionRange({ message }) {
+                        throw new Error(message);
+                    },
+                    onNoDeclaredStyledComponentsVersion({ message }) {
+                        throw new Error(message);
+                    },
+                    onNoInstalledSanityVersion({ message }) {
+                        throw new Error(message);
+                    },
+                    onNoInstalledStyledComponentsVersion({ message }) {
+                        throw new Error(message);
+                    },
+                    onPreReleaseInNonInteractiveAutoUpdate({ message }) {
+                        throw new Error(message);
+                    },
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                cleanup,
+                error: message,
+            };
+        }
+        // tar/gzip/write the built output
+        await pipeline(pack(dirname(outDir), { entries: [basename(outDir)] }), createGzip(), createWriteStream(outFile));
+        return {
+            success: true,
+            cleanup,
+            // studio must be pre built (e.g. with `npm run build`) and tarred/gzipped
+            outputPath: outFile,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            cleanup,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function createSilentOutput() {
+    return {
+        error(input, options) {
+            if (typeof options?.exit === 'number') {
+                if (input instanceof Error) {
+                    throw input;
+                }
+                throw new Error(input);
+            }
+            return undefined;
+        },
+        log() { },
+        warn(input) {
+            return input;
+        },
+    };
+}

package/dist/utils/types.d.ts

@@ -1,4 +1,4 @@
-import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentFunctionResource, type BlueprintDocumentWebhookResource, type BlueprintMediaLibraryAssetFunctionResource, type BlueprintProjectResource, type BlueprintResource, type BlueprintRobotResource, type BlueprintRoleResource, type BlueprintScheduledFunctionResource, type BlueprintSyncTagInvalidateFunctionResource } from '@sanity/blueprints';
+import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentFunctionResource, type BlueprintDocumentWebhookResource, type BlueprintMediaLibraryAssetFunctionResource, type BlueprintProjectResource, type BlueprintResource, type BlueprintRobotResource, type BlueprintRoleResource, type BlueprintScheduledFunctionResource, type BlueprintStudioResource, type BlueprintSyncTagInvalidateFunctionResource } from '@sanity/blueprints';
 export type ScopeType = 'organization' | 'project';
 /** Result utility type */
 export type Result<T, E = string> = {
@@ -16,12 +16,8 @@ export interface ActionResponse {
 /** @internal */
 export type FunctionGroqResource = BlueprintDocumentFunctionResource | BlueprintMediaLibraryAssetFunctionResource;
 export type FunctionResource = FunctionGroqResource | BlueprintScheduledFunctionResource | BlueprintSyncTagInvalidateFunctionResource;
-export interface StudioResource extends BlueprintResource {
-    type: 'sanity.studio';
-    src: string;
-}
 /** Resource types that carry a deployable asset (have src: string) */
-export type AssetResource = FunctionResource | StudioResource;
+export type AssetResource = FunctionResource | BlueprintStudioResource;
 /** @internal */
 export interface AuthParams {
     token: string;
@@ -46,7 +42,7 @@ export declare function isProjectResource(r: unknown): r is BlueprintProjectReso
 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;
-export declare function isStudioResource(r: BlueprintResource): r is StudioResource;
+export declare function isStudioResource(r: BlueprintResource): r is BlueprintStudioResource;
 export declare function isAssetResource(r: BlueprintResource): r is AssetResource;
 export declare function isWebhookResource(r: unknown): r is BlueprintDocumentWebhookResource;
 interface StackBase {
@@ -84,6 +80,7 @@ export interface StackMutation {
         resources?: BlueprintResource[];
     };
     userMessage?: string;
+    preDeploy?: boolean;
 }
 /** @internal */
 export interface BuildPayloadOptions {
@@ -126,6 +123,8 @@ export interface InvokeGroqContextOptions {
     functionResourceId: string;
     /** All resources declared by the blueprint, used to populate `context.resources` at invoke time. */
     resources?: BlueprintResource[];
+    /** The directory where the blueprint manifest is located. */
+    blueprintFileDir: string;
 }
 /** @internal */
 export interface InvokeScheduleContextOptions {
@@ -134,6 +133,8 @@ export interface InvokeScheduleContextOptions {
     };
     /** All resources declared by the blueprint, used to populate `context.resources` at invoke time. */
     resources?: BlueprintResource[];
+    /** The directory where the blueprint manifest is located. */
+    blueprintFileDir: string;
 }
 export type InvokeContextOptions = InvokeGroqContextOptions | InvokeScheduleContextOptions;
 export declare function isGroqContextOptions(context: InvokeContextOptions): context is InvokeGroqContextOptions;
@@ -265,7 +266,7 @@ export declare interface FetchConfig {
     apiHost?: string;
     apiVersion?: string;
 }
-export declare const INSTALLER_OPTIONS: readonly ["npm", "pnpm", "yarn"];
+export declare const INSTALLER_OPTIONS: readonly ['npm', 'pnpm', 'yarn'];
 export type InstallerType = 'npm' | 'pnpm' | 'yarn';
 export type AssetPrepResult = {
     success: true;

package/dist/utils/types.js

@@ -1,5 +1,5 @@
 import { validateCorsOrigin, validateDataset, validateDocumentWebhook, validateProject, validateRobot, validateRole, } from '@sanity/blueprints';
-import { SANITY_FUNCTION_PREFIX } from '../constants.js';
+import { SANITY_FUNCTION_PREFIX, SANITY_STUDIO } from '../constants.js';
 export function isLocalFunctionResource(r) {
     return r.type.startsWith(SANITY_FUNCTION_PREFIX);
 }
@@ -22,9 +22,8 @@ export function isRoleResource(r) {
 export function isDatasetResource(r) {
     return validateDataset(r).length === 0;
 }
-// TODO: update to use blueprints helpers once available
 export function isStudioResource(r) {
-    return r.type === 'sanity.studio';
+    return r.type === SANITY_STUDIO;
 }
 export function isAssetResource(r) {
     return isLocalFunctionResource(r) || isStudioResource(r);