@sanity/runtime-cli 17.13.1 → 17.14.0-next.g792820f

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

@@ -0,0 +1,38 @@
+import type { BlueprintApplicationResource, BlueprintInstallationConfigResource, BlueprintStudioResource } from '@sanity/blueprints';
+import { type BuildStudioEventListener } from '@sanity/cli-build/_internal/build';
+import type { Output } from '@sanity/cli-core';
+import type { AssetPrepResult } from '../types.js';
+export type BundleResource = BlueprintStudioResource | BlueprintApplicationResource | BlueprintInstallationConfigResource;
+type BuildContext<R extends BundleResource> = {
+    resource: R;
+    appId: string | undefined;
+    workDir: string;
+    outDir: string;
+    output: Output;
+    eventListener: Partial<BuildStudioEventListener>;
+};
+type BuildResult = {
+    mismatchedPackages?: string[];
+};
+export declare const BUNDLE_SPECS: {
+    'sanity.studio': {
+        requiresAppId: true;
+        build: typeof buildStudioBundle;
+    };
+    'sanity.application': {
+        requiresAppId: true;
+        build: typeof buildApplicationBundle;
+    };
+    'sanity.installation.config': {
+        requiresAppId: false;
+        build: typeof buildInstallationConfigBundle;
+    };
+};
+export declare function prepareBundleAsset<R extends BundleResource>({ blueprintFileDir, resource, }: {
+    blueprintFileDir: string;
+    resource: R;
+}): Promise<AssetPrepResult>;
+declare function buildStudioBundle({ resource, appId, workDir, outDir, output, eventListener, }: BuildContext<BlueprintStudioResource>): Promise<BuildResult>;
+declare function buildApplicationBundle({ resource, appId, workDir, outDir, output, eventListener, }: BuildContext<BlueprintApplicationResource>): Promise<BuildResult>;
+declare function buildInstallationConfigBundle({ resource, workDir, outDir, output, eventListener, }: BuildContext<BlueprintInstallationConfigResource>): Promise<BuildResult>;
+export {};

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

@@ -0,0 +1,271 @@
+import { createWriteStream } from 'node:fs';
+import { mkdtemp, readFile, 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 { buildApp, buildStudio, compareDependencyVersions, } from '@sanity/cli-build/_internal/build';
+import { getLocalPackageVersion } from '@sanity/cli-core';
+import { pack } from 'tar-fs';
+export const BUNDLE_SPECS = {
+    'sanity.studio': { requiresAppId: true, build: buildStudioBundle },
+    'sanity.application': { requiresAppId: true, build: buildApplicationBundle },
+    'sanity.installation.config': { requiresAppId: false, build: buildInstallationConfigBundle },
+};
+export async function prepareBundleAsset({ blueprintFileDir, resource, }) {
+    // The lookup can't prove it yields the spec matching this R, so it's asserted once here.
+    const spec = BUNDLE_SPECS[resource.type];
+    const appId = getAppId(resource);
+    if (spec.requiresAppId && !appId) {
+        return {
+            success: false,
+            async cleanup() { },
+            error: `Unable to determine appId for ${resource.type} resource '${resource.name}'`,
+        };
+    }
+    let cleanup = async () => { };
+    const assetPath = String(resource.root);
+    const workDir = path.resolve(blueprintFileDir, assetPath);
+    // Defence in depth alongside blueprints-node's own check: an absolute path or one
+    // that climbs above the blueprint dir would bundle files outside the project.
+    if (path.isAbsolute(assetPath) || path.relative(blueprintFileDir, workDir).startsWith('..')) {
+        return {
+            success: false,
+            cleanup,
+            error: `Property 'root' on resource with type '${resource.type}' must be under the blueprint directory`,
+        };
+    }
+    try {
+        const workDirStat = await stat(workDir);
+        if (!workDirStat.isDirectory()) {
+            return {
+                success: false,
+                cleanup,
+                error: `Property 'root' 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 'root' on resource with type '${resource.type}': ${msg}`,
+        };
+    }
+    try {
+        const outDir = await mkdtemp(join(tmpdir(), `bundle-`));
+        const outFile = `${outDir}.tar.gz`;
+        cleanup = async () => {
+            await rm(outDir, { force: true, recursive: true });
+            await rm(outFile, { force: true });
+        };
+        let mismatchedPackages;
+        try {
+            ;
+            ({ mismatchedPackages } = await spec.build({
+                resource,
+                appId,
+                workDir,
+                outDir,
+                output: createSilentOutput(),
+                eventListener,
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                cleanup,
+                error: message,
+            };
+        }
+        await pipeline(pack(dirname(outDir), { entries: [basename(outDir)] }), createGzip(), createWriteStream(outFile));
+        const buffer = await readFile(outFile);
+        return {
+            success: true,
+            cleanup,
+            outputBuffer: buffer,
+            fileExtension: 'tar.gz',
+            assetParameter: 'root',
+            metadata: {
+                sanityVersion: await getInstalledSanityVersion(workDir),
+                mismatchedPackages,
+                assetBytes: buffer.length,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            cleanup,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function buildStudioBundle({ resource, appId, workDir, outDir, output, eventListener, }) {
+    let mismatchedPackages;
+    await buildStudio({
+        appId,
+        autoUpdatesEnabled: resource.autoUpdates.enabled,
+        checkAppId() { },
+        async compareDependencyVersions(packages) {
+            const result = await compareDependencyVersions(packages, workDir, { appId });
+            mismatchedPackages = result.mismatched.map((m) => m.pkg);
+            return result;
+        },
+        determineBasePath() {
+            return resource.basePath ?? '/';
+        },
+        // a studio is a standalone app, not a workbench module-federation app
+        isApp: false,
+        isBlueprints: true,
+        isWorkbenchApp: false,
+        minify: resource.minify ?? true,
+        outDir,
+        output,
+        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,
+        eventListener,
+    });
+    return { mismatchedPackages };
+}
+async function buildApplicationBundle({ resource, appId, workDir, outDir, output, eventListener, }) {
+    const views = resource.views ?? [];
+    const [window, extraWindow] = views.filter((v) => v.type === 'app');
+    if (extraWindow) {
+        throw new Error(`Application resource '${resource.name}' declares more than one window view; at most one is allowed`);
+    }
+    await buildApp({
+        ...sharedBuildAppOptions({ appId, workDir, outDir, output, eventListener }),
+        appId,
+        appTitle: resource.title,
+        entry: window?.src,
+        workbenchAppId: appId,
+        exposes: {
+            views: views.map(toWorkbenchView),
+            webWorkers: resource.webWorkers,
+        },
+    });
+    // a workbench app never auto-updates, so no dependency mismatches are compared
+    return {};
+}
+async function buildInstallationConfigBundle({ resource, workDir, outDir, output, eventListener, }) {
+    await buildApp({
+        ...sharedBuildAppOptions({ appId: undefined, workDir, outDir, output, eventListener }),
+        appId: undefined,
+        appTitle: undefined,
+        entry: undefined,
+        workbenchAppId: undefined,
+        exposes: { config: { appType: resource.appType, fields: resource.fields } },
+    });
+    return {};
+}
+// Options a workbench build (application or installation config) always sets the
+// same way; each caller adds only what differs (identity, entry, exposes).
+function sharedBuildAppOptions({ appId, workDir, outDir, output, eventListener, }) {
+    return {
+        autoUpdatesEnabled: false,
+        checkAppId() { },
+        async compareDependencyVersions(packages) {
+            return compareDependencyVersions(packages, workDir, { appId });
+        },
+        determineBasePath() {
+            return '/';
+        },
+        isWorkbenchApp: true,
+        isBlueprints: true,
+        minify: true,
+        outDir,
+        output,
+        reactCompiler: false,
+        schemaExtraction: undefined,
+        sourceMap: false,
+        stats: false,
+        unattendedMode: true,
+        vite: undefined,
+        workDir,
+        eventListener,
+    };
+}
+// blueprints-node emits `type` (window views as `app`); workbench-cli discriminates on `surface`.
+function toWorkbenchView(view) {
+    switch (view.type) {
+        case 'app': {
+            const { type: _type, ...rest } = view;
+            return { ...rest, surface: 'window' };
+        }
+        case 'panel': {
+            const { type, ...rest } = view;
+            return { ...rest, surface: type };
+        }
+        case 'asset_source': {
+            const { type, ...rest } = view;
+            return { ...rest, surface: type };
+        }
+        case 'tile': {
+            const { type, ...rest } = view;
+            return { ...rest, surface: type };
+        }
+    }
+}
+const 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);
+    },
+};
+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;
+        },
+    };
+}
+async function getInstalledSanityVersion(workDir) {
+    try {
+        return (await getLocalPackageVersion('sanity', workDir)) ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getAppId(resource) {
+    if ('externalId' in resource && typeof resource.externalId === 'string' && resource.externalId) {
+        return resource.externalId;
+    }
+    else if (resource.lifecycle?.ownershipAction?.type === 'attach') {
+        return resource.lifecycle.ownershipAction.id;
+    }
+    return undefined;
+}

package/dist/utils/bundles/stamp-config-version.d.ts

@@ -0,0 +1,5 @@
+import type { BlueprintResource } from '@sanity/blueprints';
+/**
+ * Stamps the installed `sanity` version onto each media-library config resource and studio resource.
+ */
+export declare const stampConfigVersion: (resource: BlueprintResource, blueprintFileDir: string) => Promise<void>;

package/dist/utils/bundles/stamp-config-version.js

@@ -0,0 +1,45 @@
+import { resolve } from 'node:path';
+import { getLocalPackageVersion } from '@sanity/cli-core/package-manager';
+import { SANITY_INSTALLATION_CONFIG, SANITY_STUDIO } from '../../constants.js';
+/**
+ * Stamps the installed `sanity` version onto each media-library config resource and studio resource.
+ */
+export const stampConfigVersion = async (resource, blueprintFileDir) => {
+    let update;
+    let root;
+    if (resource.type === SANITY_INSTALLATION_CONFIG) {
+        const config = resource;
+        if (config.appType !== 'media-library')
+            return;
+        // Leave values included in the blueprint.
+        if (config.version !== undefined)
+            return;
+        root = config.root;
+        update = (version) => {
+            config.version = version;
+        };
+    }
+    else if (resource.type === SANITY_STUDIO) {
+        const config = resource;
+        // Leave values included in the blueprint.
+        if (config.autoUpdates?.version !== undefined)
+            return;
+        root = config.root;
+        update = (version) => {
+            if (config.autoUpdates) {
+                config.autoUpdates.version = version;
+            }
+            else {
+                config.autoUpdates = { enabled: true, version };
+            }
+        };
+    }
+    if (update && root) {
+        const workDir = resolve(blueprintFileDir, root);
+        const version = await getLocalPackageVersion('sanity', workDir);
+        if (!version) {
+            throw new Error(`Unable to determine the installed 'sanity' version for resource '${resource.name}'; is 'sanity' installed in '${root}'?`);
+        }
+        update(version);
+    }
+};

package/dist/utils/display/blueprints-formatting.d.ts

@@ -4,7 +4,11 @@ import type { DeploymentPlan } from '../../actions/blueprints/stacks.js';
 import { type BlueprintResourceRecord, type Stack, type StackSummary } from '../types.js';
 export declare function formatTitle(title: string, name: string): string;
 export declare function formatDeployedResourceTree(resources: BlueprintResourceRecord[] | undefined, verbose?: boolean): string;
-export declare function formatStudioUrls(resources: BlueprintResourceRecord[] | undefined): string[];
+/**
+ * Returns hosted Studio URLs, one line per Studio from resource-ish shapes
+ * Searches `parameters`, `resolvedParameters` and root for `studioHost`
+ */
+export declare function formatStudioUrls(resources: (BlueprintResource | BlueprintResourceRecord)[] | undefined): string[];
 export declare function formatResourceTree(resources: BlueprintResource[] | undefined, verbose?: boolean): string;
 export declare function formatStackInfo(stack: Stack | StackSummary | Blueprint, isCurrentStack?: boolean): string;
 export declare function formatStacksListing(stacks: StackSummary[], currentStackId?: string): string;

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

@@ -1,6 +1,6 @@
 import { formatDateTime, formatElapsed } from '@sanity/cli-core/dates';
 import { treeify } from 'array-treeify';
-import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, SANITY_STUDIO, } from '../../constants.js';
+import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_APPLICATION, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, SANITY_INSTALLATION_CONFIG, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, SANITY_STUDIO, } from '../../constants.js';
 import { styleText } from '../style-text.js';
 import { isCorsOriginResource, isDatasetResource, isRobotResource, isRoleResource, isStudioResource, isWebhookResource, } from '../types.js';
 import { capitalize, niceId, renderSection } from './presenters.js';
@@ -65,6 +65,14 @@ const RESOURCE_CATEGORIES = {
             return isStudioResource(res) ? arrayifyStudio(res) : [];
         },
     },
+    [SANITY_APPLICATION]: {
+        label: 'Applications',
+        displayNameAttribute: 'title',
+    },
+    [SANITY_INSTALLATION_CONFIG]: {
+        label: 'Installation configs',
+        displayNameAttribute: 'name',
+    },
 };
 const categoryByLabel = Object.values(RESOURCE_CATEGORIES).reduce((acc, curr) => {
     acc[curr.label] = curr;
@@ -165,6 +173,10 @@ export function formatDeployedResourceTree(resources, verbose = false) {
     (res) => ({ name: res.name, type: res.type, ...(res.resolvedParameters ?? res.parameters) }), verbose);
     return `${treeify(output)}\n`;
 }
+/**
+ * Returns hosted Studio URLs, one line per Studio from resource-ish shapes
+ * Searches `parameters`, `resolvedParameters` and root for `studioHost`
+ */
 export function formatStudioUrls(resources) {
     if (!resources)
         return [];
@@ -172,7 +184,8 @@ export function formatStudioUrls(resources) {
     for (const res of resources) {
         if (res.type !== SANITY_STUDIO)
             continue;
-        const host = studioHost(res.resolvedParameters ?? res.parameters);
+        const { resolvedParameters, parameters } = res;
+        const host = studioHost(resolvedParameters ?? parameters ?? res);
         if (host)
             lines.push(`Studio ${styleText(['bold', 'green'], res.name)} ${studioUrl(host)}`);
     }

package/dist/utils/{blueprints → functions}/extract-durable-config.d.ts

@@ -2,7 +2,7 @@ import { type BlueprintResource } from '@sanity/blueprints';
 /**
  * Extracts the blueprint config from the function source code and mutates it to the resource object.
  * This is used for durable functions that may not have a config defined in the blueprint.
- * @param resources
+ * @param resource
  * @param blueprintFileDir
  */
-export declare const extractDurableConfig: (resources: BlueprintResource[], blueprintFileDir: string) => Promise<void>;
+export declare const extractDurableConfig: (resource: BlueprintResource, blueprintFileDir: string) => Promise<void>;

package/dist/utils/functions/extract-durable-config.js

@@ -0,0 +1,58 @@
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { validateDurableFunction, } from '@sanity/blueprints';
+import { SANITY_FUNCTION_DURABLE } from '../../constants.js';
+import { isLocalFunctionResource } from '../types.js';
+import { findFunctionEntryPoint } from './find-entry-point.js';
+import { transpileFunction } from './transpile/function.js';
+const DURABLE_CONFIG_KEYS = ['event', 'concurrency', 'debounce', 'debounceKey'];
+/**
+ * Extracts the blueprint config from the function source code and mutates it to the resource object.
+ * This is used for durable functions that may not have a config defined in the blueprint.
+ * @param resource
+ * @param blueprintFileDir
+ */
+export const extractDurableConfig = async (resource, blueprintFileDir) => {
+    if (!isLocalFunctionResource(resource))
+        return;
+    // skip if not a durable function
+    if (resource.type !== SANITY_FUNCTION_DURABLE)
+        return;
+    // Check if source needs to be transpiled before attempting to get config
+    const resourceSrc = resolve(blueprintFileDir, resource.src);
+    const entryPoint = await findFunctionEntryPoint(resourceSrc, resource.name);
+    let importPath = entryPoint;
+    let cleanup = async () => { };
+    // need to transpile and grab the config from the built output if the entry point is a TypeScript file
+    if (entryPoint.endsWith('.ts')) {
+        const built = await transpileFunction({ resource, functionPath: resourceSrc, entryPoint });
+        importPath = await findFunctionEntryPoint(built.outputDir, resource.name);
+        cleanup = built.cleanup;
+    }
+    let config = {};
+    try {
+        const mod = await import(pathToFileURL(importPath).href);
+        config = (mod.handler || mod.default)?.config;
+    }
+    finally {
+        await cleanup();
+    }
+    // Update values not included in the blueprint.
+    if (resource.event === undefined && config?.event !== undefined) {
+        resource.event = config.event;
+    }
+    if (resource.concurrency === undefined && config?.concurrency !== undefined) {
+        resource.concurrency = config.concurrency;
+    }
+    if (resource.debounce === undefined && config?.debounce !== undefined) {
+        resource.debounce = config.debounce;
+    }
+    if (resource.debounceKey === undefined && config?.debounceKey !== undefined) {
+        resource.debounceKey = config.debounceKey;
+    }
+    // Validate the resource after merging the config values
+    const errors = validateDurableFunction(resource);
+    if (errors.length > 0) {
+        throw new Error(`Invalid durable resource "${resource.name}": ${errors.map((error) => error.message).join('; ')}`);
+    }
+};

package/dist/utils/request-id.d.ts

@@ -0,0 +1,4 @@
+export declare const REQUEST_ID_HEADER = "x-request-id";
+/** Stack PUT/POST/DELETE success bodies also carry `requestId`; error bodies do not. */
+export declare function getRequestId(response?: Response, body?: unknown): string | undefined;
+export declare function withRequestId(message: string, requestId?: string): string;

package/dist/utils/request-id.js

@@ -0,0 +1,19 @@
+export const REQUEST_ID_HEADER = 'x-request-id';
+/** Stack PUT/POST/DELETE success bodies also carry `requestId`; error bodies do not. */
+export function getRequestId(response, body) {
+    const fromHeader = response?.headers.get(REQUEST_ID_HEADER);
+    if (fromHeader)
+        return fromHeader;
+    if (body && typeof body === 'object' && 'requestId' in body) {
+        const fromBody = body.requestId;
+        if (typeof fromBody === 'string' && fromBody)
+            return fromBody;
+    }
+    return undefined;
+}
+export function withRequestId(message, requestId) {
+    if (!requestId)
+        return message;
+    const suffix = `(request ID ${requestId})`;
+    return message.endsWith('.') ? `${message.slice(0, -1)} ${suffix}.` : `${message} ${suffix}`;
+}

package/dist/utils/types.d.ts

@@ -65,6 +65,15 @@ interface StackBase {
 export interface Stack extends StackBase {
     resources: Array<BlueprintResourceRecord>;
 }
+/**
+ * Shape returned by `PUT /stacks/{id}`
+ * The authored document is echoed by the API: resources without `parameters` or `resolvedParameters`.
+ */
+export interface UpdatedStack extends StackBase {
+    resources: BlueprintResource[];
+    operationId: string;
+    changeCount?: number;
+}
 export interface StackSummary extends StackBase {
     resourceCount: number;
 }
@@ -329,11 +338,17 @@ export type PrepAssetFn<R extends BlueprintResource> = (options: {
     blueprintFileDir: string;
     installer?: InstallerType;
 }) => Promise<AssetPrepResult>;
+export type PrepResourceFn<R extends BlueprintResource> = (options: {
+    resource: R;
+    blueprintFileDir: string;
+}) => Promise<void>;
 export type PreDeployConfig = {
     /** The resource type this config applies to or a function that returns true if this config applies to the given type. */
     resourceType: string | ((type: string) => boolean);
     /** Function that takes a resource and returns a buffer to be sent to blueprints. */
     prepareAsset?: PrepAssetFn<BlueprintResource>;
+    /** Function that mutates the resource before the pre-deploy is executed. */
+    prepareResource?: PrepResourceFn<BlueprintResource>;
 };
 export type AssetResource<R extends BlueprintResource> = {
     resource: R;

package/oclif.manifest.json

@@ -3148,5 +3148,5 @@
       ]
     }
   },
-  "version": "17.13.1"
+  "version": "17.14.0-next.g792820f"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "17.13.1",
+  "version": "17.14.0-next.g792820f",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -68,7 +68,7 @@
     "@oclif/core": "^4.14.0",
     "@oclif/plugin-help": "^6.3.0",
     "@sanity-labs/oclif-plugin-skills-flag": "^0.2.1",
-    "@sanity/blueprints": "^0.24.0",
+    "@sanity/blueprints": "^0.27.0",
     "@sanity/blueprints-parser": "^0.5.0",
     "@sanity/cli-build": "^6.3.0",
     "@sanity/cli-core": "^3.7.0",

package/dist/utils/blueprints/extract-durable-config.js

@@ -1,60 +0,0 @@
-import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { validateDurableFunction, } from '@sanity/blueprints';
-import { SANITY_FUNCTION_DURABLE } from '../../constants.js';
-import { findFunctionEntryPoint } from '../functions/find-entry-point.js';
-import { transpileFunction } from '../functions/transpile/function.js';
-import { isLocalFunctionResource } from '../types.js';
-const DURABLE_CONFIG_KEYS = ['event', 'concurrency', 'debounce', 'debounceKey'];
-/**
- * Extracts the blueprint config from the function source code and mutates it to the resource object.
- * This is used for durable functions that may not have a config defined in the blueprint.
- * @param resources
- * @param blueprintFileDir
- */
-export const extractDurableConfig = async (resources, blueprintFileDir) => {
-    for (const resource of resources) {
-        if (!isLocalFunctionResource(resource))
-            continue;
-        // skip if not a durable function
-        if (resource.type !== SANITY_FUNCTION_DURABLE)
-            continue;
-        // Check if source needs to be transpiled before attempting to get config
-        const resourceSrc = resolve(blueprintFileDir, resource.src);
-        const entryPoint = await findFunctionEntryPoint(resourceSrc, resource.name);
-        let importPath = entryPoint;
-        let cleanup = async () => { };
-        // need to transpile and grab the config from the built output if the entry point is a TypeScript file
-        if (entryPoint.endsWith('.ts')) {
-            const built = await transpileFunction({ resource, functionPath: resourceSrc, entryPoint });
-            importPath = await findFunctionEntryPoint(built.outputDir, resource.name);
-            cleanup = built.cleanup;
-        }
-        let config = {};
-        try {
-            const mod = await import(pathToFileURL(importPath).href);
-            config = (mod.handler || mod.default)?.config;
-        }
-        finally {
-            await cleanup();
-        }
-        // Update values not included in the blueprint.
-        if (resource.event === undefined && config?.event !== undefined) {
-            resource.event = config.event;
-        }
-        if (resource.concurrency === undefined && config?.concurrency !== undefined) {
-            resource.concurrency = config.concurrency;
-        }
-        if (resource.debounce === undefined && config?.debounce !== undefined) {
-            resource.debounce = config.debounce;
-        }
-        if (resource.debounceKey === undefined && config?.debounceKey !== undefined) {
-            resource.debounceKey = config.debounceKey;
-        }
-        // Validate the resource after merging the config values
-        const errors = validateDurableFunction(resource);
-        if (errors.length > 0) {
-            throw new Error(`Invalid durable resource "${resource.name}": ${errors.map((error) => error.message).join('; ')}`);
-        }
-    }
-};

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

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