experimental-ash 0.26.0 → 0.27.0

package/dist/src/internal/workflow-bundle/builder.js

@@ -1,472 +1,5 @@
-import { Buffer } from "node:buffer";
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join, relative, resolve } from "node:path";
-import { resolvePackageSourceDirectoryPath, resolveWorkflowModulePath, } from "#internal/application/package.js";
-import { prepareAshVersionedCacheDirectory, writeAshVersionedCacheMetadata, } from "#internal/application/cache-metadata.js";
-import { normalizeEsmImportSpecifier } from "#internal/application/import-specifier.js";
-import { atomicWriteFile, bundleFinalWorkflowOutput, collectWorkflowInputFiles, convertClassesManifest, convertStepsManifest, convertWorkflowsManifest, createAshPackageImportsPlugin, createWorkflowImport, createWorkflowPseudoPackagePlugin, createWorkflowTransformPlugin, createWorkflowVirtualEntryPlugin, WORKFLOW_VIRTUAL_ENTRY_ID, } from "#internal/workflow-bundle/builder-support.js";
-import { buildWithNitroRolldown, getSingleRolldownChunk, } from "#internal/bundler/nitro-rolldown.js";
-import { writeNitroStepEntrypoint } from "#internal/workflow-bundle/nitro-step-entry.js";
-import { copyNitroFunctionDirectory, createWorkflowFunctionEnvironment, retargetNitroFunctionDirectoryToWorkflowRoute, WORKFLOW_BUILDER_DEFERRED_PACKAGES, WORKFLOW_STEP_EXTERNAL_PACKAGES, } from "#internal/workflow-bundle/vercel-workflow-output.js";
-import { detectWorkflowPatterns, WORKFLOW_QUEUE_TRIGGER, } from "#internal/workflow-bundle/workflow-builders.js";
-// Serialize same-output builds so parallel Vercel surfaces never read
-// `workflows.mjs` between the workflow wrapper write and literal rewrite pass.
-const workflowBundleBuildLocks = new Map();
-export class WorkflowBundleBuilder {
-    #compiledArtifactsBootstrapPath;
-    #outDir;
-    config;
-    #discoveredEntries = new WeakMap();
-    constructor(options) {
-        this.config = {
-            buildTarget: "standalone",
-            dirs: [resolvePackageSourceDirectoryPath("src/execution")],
-            externalPackages: [...WORKFLOW_STEP_EXTERNAL_PACKAGES, ...WORKFLOW_BUILDER_DEFERRED_PACKAGES],
-            // Keep package-version workflow ids stable across bundling targets.
-            projectRoot: options.appRoot,
-            watch: options.watch,
-            workingDir: options.rootDir,
-        };
-        this.#compiledArtifactsBootstrapPath = options.compiledArtifactsBootstrapPath;
-        this.#outDir = options.outDir;
-    }
-    async build(options = {}) {
-        const previous = workflowBundleBuildLocks.get(this.#outDir) ?? Promise.resolve();
-        const next = previous.then(() => this.#performBuild(options));
-        workflowBundleBuildLocks.set(this.#outDir, next.catch(() => { }));
-        await next;
-    }
-    async #performBuild(options) {
-        await prepareAshVersionedCacheDirectory(this.#outDir);
-        const inputFiles = await this.#getBuildInputFiles();
-        if (inputFiles.length === 0) {
-            throw new Error(`Expected the execution workflow source file under "${resolvePackageSourceDirectoryPath("src/execution")}".`);
-        }
-        const tsconfigPath = await this.findTsConfigPath();
-        await mkdir(this.#outDir, { recursive: true });
-        const discoveredEntries = await this.discoverEntries(inputFiles, this.#outDir, tsconfigPath);
-        const workflowsOutfile = join(this.#outDir, "workflows.mjs");
-        const { manifest: workflowsManifest } = await this.createWorkflowsBundle({
-            discoveredEntries,
-            // Ash owns dev rebuilds through `dev-authored-source-watcher`.
-            keepInterimBundleContext: false,
-            outfile: workflowsOutfile,
-            bundleFinalOutput: false,
-            format: "esm",
-            inputFiles,
-            tsconfigPath,
-        });
-        const stepsOutfile = join(this.#outDir, "steps.mjs");
-        const stepsManifest = await writeNitroStepEntrypoint({
-            builtinsPath: resolveWorkflowModulePath("workflow/internal/builtins"),
-            discoveredEntries,
-            outfile: stepsOutfile,
-            preferAbsoluteFileImports: true,
-            projectRoot: this.config.projectRoot ?? this.config.workingDir,
-            workingDir: this.config.workingDir,
-        });
-        const nitroStepOutfile = options.nitroStepOutfile;
-        if (nitroStepOutfile !== undefined && nitroStepOutfile !== stepsOutfile) {
-            await writeNitroStepEntrypoint({
-                builtinsPath: resolveWorkflowModulePath("workflow/internal/builtins"),
-                discoveredEntries,
-                outfile: nitroStepOutfile,
-                preferAbsoluteFileImports: true,
-                projectRoot: this.config.projectRoot ?? this.config.workingDir,
-                workingDir: this.config.workingDir,
-            });
-        }
-        await addStepRegistrationsImport(workflowsOutfile, stepsOutfile);
-        await rewriteWorkflowRuntimeImports(workflowsOutfile);
-        await rewriteWorkflowCodeLiteral(workflowsOutfile);
-        const nitroWorkflowOutfile = options.nitroWorkflowOutfile;
-        if (nitroWorkflowOutfile !== undefined && nitroWorkflowOutfile !== workflowsOutfile) {
-            await mkdir(dirname(nitroWorkflowOutfile), { recursive: true });
-            await mirrorFileBypassingUnlink(workflowsOutfile, nitroWorkflowOutfile);
-            if (nitroStepOutfile !== undefined) {
-                await addStepRegistrationsImport(nitroWorkflowOutfile, nitroStepOutfile);
-                await rewriteWorkflowRuntimeImports(nitroWorkflowOutfile);
-                await rewriteWorkflowCodeLiteral(nitroWorkflowOutfile);
-            }
-        }
-        await this.createManifest({
-            workflowBundlePath: join(this.#outDir, "workflows.mjs"),
-            manifestDir: this.#outDir,
-            manifest: {
-                steps: {
-                    ...stepsManifest.steps,
-                    ...workflowsManifest.steps,
-                },
-                workflows: {
-                    ...stepsManifest.workflows,
-                    ...workflowsManifest.workflows,
-                },
-                classes: {
-                    ...stepsManifest.classes,
-                    ...workflowsManifest.classes,
-                },
-            },
-        });
-        await writeAshVersionedCacheMetadata(this.#outDir);
-        // Workflow bundle output may use bare `workflow/*` specifiers.
-    }
-    get transformProjectRoot() {
-        return this.config.projectRoot ?? this.config.workingDir;
-    }
-    async findTsConfigPath() {
-        let current = this.config.workingDir;
-        while (true) {
-            for (const filename of ["tsconfig.json", "jsconfig.json"]) {
-                const candidate = join(current, filename);
-                try {
-                    await readFile(candidate);
-                    return candidate;
-                }
-                catch (error) {
-                    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
-                        throw error;
-                    }
-                }
-            }
-            const parent = dirname(current);
-            if (parent === current) {
-                return undefined;
-            }
-            current = parent;
-        }
-    }
-    async getInputFiles() {
-        const roots = this.config.dirs.map((dir) => resolve(this.config.workingDir, dir));
-        const files = await Promise.all(roots.map((root) => collectWorkflowInputFiles(root)));
-        return files.flat();
-    }
-    async discoverEntries(inputs, _outdir, _tsconfigPath) {
-        const cached = this.#discoveredEntries.get(inputs);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const discovered = {
-            discoveredSerdeFiles: [],
-            discoveredSteps: [],
-            discoveredWorkflows: [],
-        };
-        for (const filePath of inputs) {
-            const source = await readFile(filePath, "utf8");
-            const patterns = detectWorkflowPatterns(source);
-            if (patterns.hasUseStep) {
-                discovered.discoveredSteps.push(filePath);
-            }
-            if (patterns.hasUseWorkflow) {
-                discovered.discoveredWorkflows.push(filePath);
-            }
-            if (patterns.hasSerde) {
-                discovered.discoveredSerdeFiles.push(filePath);
-            }
-        }
-        this.#discoveredEntries.set(inputs, discovered);
-        return discovered;
-    }
-    async createWorkflowsBundle({ bundleFinalOutput = true, discoveredEntries, format = "cjs", inputFiles, keepInterimBundleContext = this.config.watch, outfile, tsconfigPath, }) {
-        const discovered = discoveredEntries ?? (await this.discoverEntries(inputFiles, dirname(outfile), tsconfigPath));
-        const workflowFiles = [...discovered.discoveredWorkflows].sort();
-        const workflowFileSet = new Set(workflowFiles);
-        const serdeOnlyFiles = [...discovered.discoveredSerdeFiles]
-            .sort()
-            .filter((filePath) => !workflowFileSet.has(filePath));
-        const workflowManifest = {};
-        const virtualEntrySource = [
-            ...workflowFiles.map((filePath) => createWorkflowImport(filePath, this.config.workingDir)),
-            ...serdeOnlyFiles.map((filePath) => createWorkflowImport(filePath, this.config.workingDir)),
-        ].join("\n");
-        const output = await buildWithNitroRolldown({
-            cwd: this.config.workingDir,
-            input: WORKFLOW_VIRTUAL_ENTRY_ID,
-            platform: "neutral",
-            plugins: [
-                createWorkflowVirtualEntryPlugin(virtualEntrySource),
-                createWorkflowPseudoPackagePlugin(),
-                createAshPackageImportsPlugin(this.config.workingDir, { workflowCondition: true }),
-                createWorkflowTransformPlugin({
-                    manifest: workflowManifest,
-                    projectRoot: this.transformProjectRoot,
-                    sideEffectFiles: [...workflowFiles, ...serdeOnlyFiles],
-                    workingDir: this.config.workingDir,
-                }),
-            ],
-            resolve: {
-                conditionNames: ["ash-source", "workflow", "node", "import", "default"],
-                extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
-                mainFields: ["module", "main"],
-            },
-            tsconfig: tsconfigPath ?? false,
-            write: false,
-            output: {
-                banner: "globalThis.__private_workflows = new Map();",
-                codeSplitting: false,
-                comments: false,
-                format: "cjs",
-                sourcemap: "inline",
-            },
-        });
-        const interimBundle = getSingleRolldownChunk(output, `intermediate workflow bundle for "${outfile}"`);
-        await bundleFinalWorkflowOutput({
-            bundleFinalOutput,
-            code: interimBundle.code,
-            format,
-            outfile,
-            workingDir: this.config.workingDir,
-        });
-        if (keepInterimBundleContext) {
-            return {
-                bundleFinal: async (interimBundleResult) => {
-                    await bundleFinalWorkflowOutput({
-                        bundleFinalOutput,
-                        code: interimBundleResult,
-                        format,
-                        outfile,
-                        workingDir: this.config.workingDir,
-                    });
-                },
-                interimBundleCtx: undefined,
-                manifest: workflowManifest,
-            };
-        }
-        return { manifest: workflowManifest };
-    }
-    async createManifest({ manifest, manifestDir, }) {
-        const output = {
-            version: "1.0.0",
-            steps: convertStepsManifest(manifest.steps),
-            workflows: convertWorkflowsManifest(manifest.workflows),
-            classes: convertClassesManifest(manifest.classes),
-        };
-        const manifestJson = JSON.stringify(output, null, 2);
-        await mkdir(manifestDir, { recursive: true });
-        await writeFile(join(manifestDir, "manifest.json"), manifestJson);
-        return manifestJson;
-    }
-    async buildVercelOutput(options) {
-        await this.build();
-        const stagedWorkflowGeneratedDir = join(this.#outDir, "vercel-build-output", "functions", ".well-known", "workflow", "v1");
-        const stagedFlowFunctionDir = join(stagedWorkflowGeneratedDir, "flow.func");
-        const workflowGeneratedDir = join(options.outputDir, "functions", ".well-known", "workflow", "v1");
-        const nitroFlowServerFunctionDir = join(options.flowNitroOutputDir, "functions", "__server.func");
-        const nitroFlowFunctionDir = join(options.flowNitroOutputDir, "functions", ".well-known", "workflow", "v1", "flow.func");
-        const flowFunctionDir = join(workflowGeneratedDir, "flow.func");
-        const staleStepFunctionDir = join(workflowGeneratedDir, "step.func");
-        const staleWebhookFunctionDir = join(workflowGeneratedDir, "webhook", "[token].func");
-        await copyNitroFunctionDirectory({
-            fallbackPath: nitroFlowServerFunctionDir,
-            sourcePath: nitroFlowFunctionDir,
-            targetPath: stagedFlowFunctionDir,
-        });
-        await Promise.all([
-            this.#patchVercelFunctionConfig(stagedFlowFunctionDir, {
-                experimentalTriggers: Array.from([WORKFLOW_QUEUE_TRIGGER]),
-                maxDuration: "max",
-                runtime: options.runtime ?? null,
-                shouldAddHelpers: false,
-            }),
-            cp(join(this.#outDir, "manifest.json"), join(stagedWorkflowGeneratedDir, "manifest.json")),
-        ]);
-        await retargetNitroFunctionDirectoryToWorkflowRoute({
-            functionDirectoryPath: stagedFlowFunctionDir,
-            workflowRoutePath: "/.well-known/workflow/v1/flow",
-        });
-        await Promise.all([
-            rm(flowFunctionDir, {
-                force: true,
-                recursive: true,
-            }),
-            rm(staleStepFunctionDir, {
-                force: true,
-                recursive: true,
-            }),
-            rm(staleWebhookFunctionDir, {
-                force: true,
-                recursive: true,
-            }),
-        ]);
-        await mkdir(workflowGeneratedDir, { recursive: true });
-        await Promise.all([
-            cp(stagedFlowFunctionDir, flowFunctionDir, { recursive: true }),
-            cp(join(stagedWorkflowGeneratedDir, "manifest.json"), join(workflowGeneratedDir, "manifest.json")),
-        ]);
-    }
-    async #getBuildInputFiles() {
-        const inputFiles = await this.getInputFiles();
-        return [...inputFiles, this.#compiledArtifactsBootstrapPath];
-    }
-    async #patchVercelFunctionConfig(directoryPath, patch) {
-        const configPath = join(directoryPath, ".vc-config.json");
-        const baseConfig = await this.#readVercelFunctionConfig(configPath);
-        const nextConfig = {
-            ...baseConfig,
-        };
-        nextConfig.environment = createWorkflowFunctionEnvironment(baseConfig.environment);
-        if (patch.runtime !== null) {
-            nextConfig.runtime = patch.runtime;
-        }
-        if (patch.maxDuration !== undefined) {
-            nextConfig.maxDuration = patch.maxDuration;
-        }
-        if (patch.shouldAddHelpers !== undefined) {
-            nextConfig.shouldAddHelpers = patch.shouldAddHelpers;
-        }
-        if (patch.shouldAddSourcemapSupport !== undefined) {
-            nextConfig.shouldAddSourcemapSupport = patch.shouldAddSourcemapSupport;
-        }
-        if (patch.experimentalTriggers !== undefined) {
-            nextConfig.experimentalTriggers = [...patch.experimentalTriggers];
-        }
-        await writeFile(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`);
-    }
-    async #readVercelFunctionConfig(configPath) {
-        try {
-            const parsed = JSON.parse(await readFile(configPath, "utf8"));
-            if (parsed !== null && typeof parsed === "object") {
-                return parsed;
-            }
-        }
-        catch {
-            // fall through
-        }
-        return {};
-    }
-}
-async function addStepRegistrationsImport(workflowBundlePath, stepRegistrationsPath) {
-    const source = await readTextFileIfPresent(workflowBundlePath);
-    if (source === null || source.includes("__ashWorkflowStepsRegistered")) {
-        return;
-    }
-    const importSpecifier = createRelativeImportSpecifier(dirname(workflowBundlePath), stepRegistrationsPath);
-    const importSource = [
-        `import { __steps_registered as __ashWorkflowStepsRegistered } from ${JSON.stringify(importSpecifier)};`,
-        "void __ashWorkflowStepsRegistered;",
-        "",
-    ].join("\n");
-    const firstImportMatch = source.match(/^import\s.+?;\n/m);
-    if (firstImportMatch === null || firstImportMatch.index === undefined) {
-        await atomicWriteFile(workflowBundlePath, `${importSource}${source}`);
-        return;
-    }
-    const insertionIndex = firstImportMatch.index + firstImportMatch[0].length;
-    const nextSource = `${source.slice(0, insertionIndex)}${importSource}${source.slice(insertionIndex)}`;
-    await atomicWriteFile(workflowBundlePath, nextSource);
-}
-async function rewriteWorkflowRuntimeImports(filePath) {
-    const source = await readTextFileIfPresent(filePath);
-    if (source === null) {
-        return;
-    }
-    let nextSource = source;
-    for (const specifier of [
-        "workflow",
-        "workflow/api",
-        "workflow/internal/builtins",
-        "workflow/internal/private",
-        "workflow/runtime",
-    ]) {
-        const resolvedSpecifier = normalizeImportSpecifierPath(resolveWorkflowModulePath(specifier));
-        nextSource = replaceStringLiteralSpecifier(nextSource, specifier, resolvedSpecifier);
-    }
-    if (nextSource !== source) {
-        await atomicWriteFile(filePath, nextSource);
-    }
-}
-async function rewriteWorkflowCodeLiteral(filePath) {
-    const source = await readTextFileIfPresent(filePath);
-    if (source === null) {
-        return;
-    }
-    const declarationPrefix = "const workflowCode = ";
-    const declarationSuffix = ";\n\nexport const POST = workflowEntrypoint(workflowCode);";
-    const expressionStart = source.indexOf(declarationPrefix);
-    const expressionEnd = source.lastIndexOf(declarationSuffix);
-    if (expressionStart === -1 || expressionEnd === -1 || expressionEnd <= expressionStart) {
-        return;
-    }
-    const valueStart = expressionStart + declarationPrefix.length;
-    const expression = source.slice(valueStart, expressionEnd);
-    if (!expression.trimStart().startsWith("`")) {
-        return;
-    }
-    const workflowCode = decodeWorkflowCodeTemplateLiteral(expression, filePath);
-    const nextSource = `${source.slice(0, valueStart)}${encodeWorkflowCodeLiteral(workflowCode)}${source.slice(expressionEnd)}`;
-    if (nextSource !== source) {
-        await atomicWriteFile(filePath, nextSource);
-    }
-}
-function encodeWorkflowCodeLiteral(workflowCode) {
-    const encodedWorkflowCode = Buffer.from(workflowCode, "utf8").toString("base64");
-    const chunks = encodedWorkflowCode.match(/.{1,16384}/g) ?? [""];
-    return `Buffer.from(${JSON.stringify(chunks)}.join(""), "base64").toString("utf8")`;
-}
-function decodeWorkflowCodeTemplateLiteral(expression, filePath) {
-    const trimmedExpression = expression.trim();
-    if (!trimmedExpression.startsWith("`") || !trimmedExpression.endsWith("`")) {
-        throw new Error(`Expected generated workflow code literal in "${filePath}" to be a template.`);
-    }
-    const rawValue = trimmedExpression.slice(1, -1);
-    let value = "";
-    for (let index = 0; index < rawValue.length; index += 1) {
-        const char = rawValue[index];
-        if (char !== "\\") {
-            value += char;
-            continue;
-        }
-        const escapedChar = rawValue[index + 1];
-        if (escapedChar === "\\" || escapedChar === "`" || escapedChar === "$") {
-            value += escapedChar;
-            index += 1;
-            continue;
-        }
-        value += char;
-    }
-    return value;
-}
-function replaceStringLiteralSpecifier(source, from, to) {
-    return source
-        .replaceAll(JSON.stringify(from), JSON.stringify(to))
-        .replaceAll(`'${from}'`, JSON.stringify(to));
-}
-function normalizeImportSpecifierPath(path) {
-    return normalizeEsmImportSpecifier(path);
-}
-function createRelativeImportSpecifier(fromDirectoryPath, targetPath) {
-    const relativePath = relative(fromDirectoryPath, targetPath).replaceAll("\\", "/");
-    if (relativePath.startsWith(".")) {
-        return relativePath;
-    }
-    return `./${relativePath}`;
-}
-async function readTextFileIfPresent(filePath) {
-    try {
-        return await readFile(filePath, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-async function readBinaryFileIfPresent(filePath) {
-    try {
-        return await readFile(filePath);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-async function mirrorFileBypassingUnlink(sourcePath, targetPath) {
-    const sourceContents = await readFile(sourcePath);
-    const existingContents = await readBinaryFileIfPresent(targetPath);
-    if (existingContents !== null && existingContents.equals(sourceContents)) {
-        return;
-    }
-    await atomicWriteFile(targetPath, sourceContents);
-}
+import{dirname,join,relative,resolve}from"node:path";import{cp,mkdir,readFile,rm,writeFile}from"node:fs/promises";import{resolvePackageSourceDirectoryPath,resolveWorkflowModulePath}from"#internal/application/package.js";import{normalizeEsmImportSpecifier}from"#internal/application/import-specifier.js";import{Buffer}from"node:buffer";import{buildWithNitroRolldown,getSingleRolldownChunk}from"#internal/bundler/nitro-rolldown.js";import{prepareAshVersionedCacheDirectory,writeAshVersionedCacheMetadata}from"#internal/application/cache-metadata.js";import{WORKFLOW_BUILDER_DEFERRED_PACKAGES,WORKFLOW_STEP_EXTERNAL_PACKAGES,copyNitroFunctionDirectory,createWorkflowFunctionEnvironment,retargetNitroFunctionDirectoryToWorkflowRoute}from"#internal/workflow-bundle/vercel-workflow-output.js";import{WORKFLOW_QUEUE_TRIGGER,detectWorkflowPatterns}from"#internal/workflow-bundle/workflow-builders.js";import{WORKFLOW_VIRTUAL_ENTRY_ID,atomicWriteFile,bundleFinalWorkflowOutput,collectWorkflowInputFiles,convertClassesManifest,convertStepsManifest,convertWorkflowsManifest,createAshPackageImportsPlugin,createWorkflowImport,createWorkflowPseudoPackagePlugin,createWorkflowTransformPlugin,createWorkflowVirtualEntryPlugin}from"#internal/workflow-bundle/builder-support.js";import{writeNitroStepEntrypoint}from"#internal/workflow-bundle/nitro-step-entry.js";var workflowBundleBuildLocks=new Map,WorkflowBundleBuilder=class{#e;#t;config;#n=new WeakMap;constructor(e){this.config={buildTarget:`standalone`,dirs:[resolvePackageSourceDirectoryPath(`src/execution`)],externalPackages:[...WORKFLOW_STEP_EXTERNAL_PACKAGES,...WORKFLOW_BUILDER_DEFERRED_PACKAGES],projectRoot:e.appRoot,watch:e.watch,workingDir:e.rootDir},this.#e=e.compiledArtifactsBootstrapPath,this.#t=e.outDir}async build(e={}){let t=(workflowBundleBuildLocks.get(this.#t)??Promise.resolve()).then(()=>this.#r(e));workflowBundleBuildLocks.set(this.#t,t.catch(()=>{})),await t}async#r(n){await prepareAshVersionedCacheDirectory(this.#t);let r=await this.#i();if(r.length===0)throw Error(`Expected the execution workflow source file under "${resolvePackageSourceDirectoryPath(`src/execution`)}".`);let i=await this.findTsConfigPath();await mkdir(this.#t,{recursive:!0});let o=await this.discoverEntries(r,this.#t,i),s=join(this.#t,`workflows.mjs`),{manifest:c}=await this.createWorkflowsBundle({discoveredEntries:o,keepInterimBundleContext:!1,outfile:s,bundleFinalOutput:!1,format:`esm`,inputFiles:r,tsconfigPath:i}),d=join(this.#t,`steps.mjs`),f=await writeNitroStepEntrypoint({builtinsPath:resolveWorkflowModulePath(`workflow/internal/builtins`),discoveredEntries:o,outfile:d,preferAbsoluteFileImports:!0,projectRoot:this.config.projectRoot??this.config.workingDir,workingDir:this.config.workingDir}),p=n.nitroStepOutfile;p!==void 0&&p!==d&&await writeNitroStepEntrypoint({builtinsPath:resolveWorkflowModulePath(`workflow/internal/builtins`),discoveredEntries:o,outfile:p,preferAbsoluteFileImports:!0,projectRoot:this.config.projectRoot??this.config.workingDir,workingDir:this.config.workingDir}),await addStepRegistrationsImport(s,d),await rewriteWorkflowRuntimeImports(s),await rewriteWorkflowCodeLiteral(s);let m=n.nitroWorkflowOutfile;m!==void 0&&m!==s&&(await mkdir(dirname(m),{recursive:!0}),await mirrorFileBypassingUnlink(s,m),p!==void 0&&(await addStepRegistrationsImport(m,p),await rewriteWorkflowRuntimeImports(m),await rewriteWorkflowCodeLiteral(m))),await this.createManifest({workflowBundlePath:join(this.#t,`workflows.mjs`),manifestDir:this.#t,manifest:{steps:{...f.steps,...c.steps},workflows:{...f.workflows,...c.workflows},classes:{...f.classes,...c.classes}}}),await writeAshVersionedCacheMetadata(this.#t)}get transformProjectRoot(){return this.config.projectRoot??this.config.workingDir}async findTsConfigPath(){let n=this.config.workingDir;for(;;){for(let e of[`tsconfig.json`,`jsconfig.json`]){let r=join(n,e);try{return await readFile(r),r}catch(e){if(!(e instanceof Error&&`code`in e&&e.code===`ENOENT`))throw e}}let r=dirname(n);if(r===n)return;n=r}}async getInputFiles(){let e=this.config.dirs.map(e=>resolve(this.config.workingDir,e));return(await Promise.all(e.map(e=>collectWorkflowInputFiles(e)))).flat()}async discoverEntries(e,t,n){let r=this.#n.get(e);if(r!==void 0)return r;let i={discoveredSerdeFiles:[],discoveredSteps:[],discoveredWorkflows:[]};for(let t of e){let e=detectWorkflowPatterns(await readFile(t,`utf8`));e.hasUseStep&&i.discoveredSteps.push(t),e.hasUseWorkflow&&i.discoveredWorkflows.push(t),e.hasSerde&&i.discoveredSerdeFiles.push(t)}return this.#n.set(e,i),i}async createWorkflowsBundle({bundleFinalOutput:t=!0,discoveredEntries:n,format:r=`cjs`,inputFiles:i,keepInterimBundleContext:a=this.config.watch,outfile:o,tsconfigPath:s}){let c=n??await this.discoverEntries(i,dirname(o),s),l=[...c.discoveredWorkflows].sort(),u=new Set(l),d=[...c.discoveredSerdeFiles].sort().filter(e=>!u.has(e)),f={},h=[...l.map(e=>createWorkflowImport(e,this.config.workingDir)),...d.map(e=>createWorkflowImport(e,this.config.workingDir))].join(`
+`);return await bundleFinalWorkflowOutput({bundleFinalOutput:t,code:getSingleRolldownChunk(await buildWithNitroRolldown({cwd:this.config.workingDir,input:WORKFLOW_VIRTUAL_ENTRY_ID,platform:`neutral`,plugins:[createWorkflowVirtualEntryPlugin(h),createWorkflowPseudoPackagePlugin(),createAshPackageImportsPlugin(this.config.workingDir,{workflowCondition:!0}),createWorkflowTransformPlugin({manifest:f,projectRoot:this.transformProjectRoot,sideEffectFiles:[...l,...d],workingDir:this.config.workingDir})],resolve:{conditionNames:[`ash-source`,`workflow`,`node`,`import`,`default`],extensions:[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`],mainFields:[`module`,`main`]},tsconfig:s??!1,write:!1,output:{banner:`globalThis.__private_workflows = new Map();`,codeSplitting:!1,comments:!1,format:`cjs`,sourcemap:`inline`}}),`intermediate workflow bundle for "${o}"`).code,format:r,outfile:o,workingDir:this.config.workingDir}),a?{bundleFinal:async e=>{await bundleFinalWorkflowOutput({bundleFinalOutput:t,code:e,format:r,outfile:o,workingDir:this.config.workingDir})},interimBundleCtx:void 0,manifest:f}:{manifest:f}}async createManifest({manifest:e,manifestDir:n}){let r={version:`1.0.0`,steps:convertStepsManifest(e.steps),workflows:convertWorkflowsManifest(e.workflows),classes:convertClassesManifest(e.classes)},i=JSON.stringify(r,null,2);return await mkdir(n,{recursive:!0}),await writeFile(join(n,`manifest.json`),i),i}async buildVercelOutput(e){await this.build();let n=join(this.#t,`vercel-build-output`,`functions`,`.well-known`,`workflow`,`v1`),r=join(n,`flow.func`),o=join(e.outputDir,`functions`,`.well-known`,`workflow`,`v1`),c=join(e.flowNitroOutputDir,`functions`,`__server.func`),l=join(e.flowNitroOutputDir,`functions`,`.well-known`,`workflow`,`v1`,`flow.func`),u=join(o,`flow.func`),d=join(o,`step.func`),f=join(o,`webhook`,`[token].func`);await copyNitroFunctionDirectory({fallbackPath:c,sourcePath:l,targetPath:r}),await Promise.all([this.#a(r,{experimentalTriggers:Array.from([WORKFLOW_QUEUE_TRIGGER]),maxDuration:`max`,runtime:e.runtime??null,shouldAddHelpers:!1}),cp(join(this.#t,`manifest.json`),join(n,`manifest.json`))]),await retargetNitroFunctionDirectoryToWorkflowRoute({functionDirectoryPath:r,workflowRoutePath:`/.well-known/workflow/v1/flow`}),await Promise.all([rm(u,{force:!0,recursive:!0}),rm(d,{force:!0,recursive:!0}),rm(f,{force:!0,recursive:!0})]),await mkdir(o,{recursive:!0}),await Promise.all([cp(r,u,{recursive:!0}),cp(join(n,`manifest.json`),join(o,`manifest.json`))])}async#i(){return[...await this.getInputFiles(),this.#e]}async#a(e,n){let r=join(e,`.vc-config.json`),i=await this.#o(r),a={...i};a.environment=createWorkflowFunctionEnvironment(i.environment),n.runtime!==null&&(a.runtime=n.runtime),n.maxDuration!==void 0&&(a.maxDuration=n.maxDuration),n.shouldAddHelpers!==void 0&&(a.shouldAddHelpers=n.shouldAddHelpers),n.shouldAddSourcemapSupport!==void 0&&(a.shouldAddSourcemapSupport=n.shouldAddSourcemapSupport),n.experimentalTriggers!==void 0&&(a.experimentalTriggers=[...n.experimentalTriggers]),await writeFile(r,`${JSON.stringify(a,null,2)}\n`)}async#o(e){try{let t=JSON.parse(await readFile(e,`utf8`));if(typeof t==`object`&&t)return t}catch{}return{}}};async function addStepRegistrationsImport(t,n){let r=await readTextFileIfPresent(t);if(r===null||r.includes(`__ashWorkflowStepsRegistered`))return;let i=createRelativeImportSpecifier(dirname(t),n),a=[`import { __steps_registered as __ashWorkflowStepsRegistered } from ${JSON.stringify(i)};`,`void __ashWorkflowStepsRegistered;`,``].join(`
+`),o=r.match(/^import\s.+?;\n/m);if(o===null||o.index===void 0){await atomicWriteFile(t,`${a}${r}`);return}let s=o.index+o[0].length;await atomicWriteFile(t,`${r.slice(0,s)}${a}${r.slice(s)}`)}async function rewriteWorkflowRuntimeImports(e){let t=await readTextFileIfPresent(e);if(t===null)return;let n=t;for(let e of[`workflow`,`workflow/api`,`workflow/internal/builtins`,`workflow/internal/private`,`workflow/runtime`]){let t=normalizeImportSpecifierPath(resolveWorkflowModulePath(e));n=replaceStringLiteralSpecifier(n,e,t)}n!==t&&await atomicWriteFile(e,n)}async function rewriteWorkflowCodeLiteral(e){let t=await readTextFileIfPresent(e);if(t===null)return;let n=t.indexOf(`const workflowCode = `),r=t.lastIndexOf(`;
+
+export const POST = workflowEntrypoint(workflowCode);`);if(n===-1||r===-1||r<=n)return;let i=n+21,a=t.slice(i,r);if(!a.trimStart().startsWith("`"))return;let o=decodeWorkflowCodeTemplateLiteral(a,e),s=`${t.slice(0,i)}${encodeWorkflowCodeLiteral(o)}${t.slice(r)}`;s!==t&&await atomicWriteFile(e,s)}function encodeWorkflowCodeLiteral(e){let t=Buffer.from(e,`utf8`).toString(`base64`).match(/.{1,16384}/g)??[``];return`Buffer.from(${JSON.stringify(t)}.join(""), "base64").toString("utf8")`}function decodeWorkflowCodeTemplateLiteral(e,t){let n=e.trim();if(!n.startsWith("`")||!n.endsWith("`"))throw Error(`Expected generated workflow code literal in "${t}" to be a template.`);let r=n.slice(1,-1),i=``;for(let e=0;e<r.length;e+=1){let t=r[e];if(t!==`\\`){i+=t;continue}let n=r[e+1];if(n===`\\`||n==="`"||n===`$`){i+=n,e+=1;continue}i+=t}return i}function replaceStringLiteralSpecifier(e,t,n){return e.replaceAll(JSON.stringify(t),JSON.stringify(n)).replaceAll(`'${t}'`,JSON.stringify(n))}function normalizeImportSpecifierPath(e){return normalizeEsmImportSpecifier(e)}function createRelativeImportSpecifier(e,t){let r=relative(e,t).replaceAll(`\\`,`/`);return r.startsWith(`.`)?r:`./${r}`}async function readTextFileIfPresent(e){try{return await readFile(e,`utf8`)}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return null;throw e}}async function readBinaryFileIfPresent(e){try{return await readFile(e)}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return null;throw e}}async function mirrorFileBypassingUnlink(e,t){let n=await readFile(e),r=await readBinaryFileIfPresent(t);r!==null&&r.equals(n)||await atomicWriteFile(t,n)}export{WorkflowBundleBuilder};

package/dist/src/internal/workflow-bundle/nitro-step-entry.js

@@ -1,132 +1,2 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, relative } from "node:path";
-import { normalizeEsmImportSpecifier } from "#internal/application/import-specifier.js";
-import { applyWorkflowTransform, } from "#internal/workflow-bundle/workflow-builders.js";
-/**
- * Writes the hosted Nitro step entrypoint source and returns the manifest
- * metadata discovered from the imported step and serde files.
- */
-export async function writeNitroStepEntrypoint(input) {
-    const stepFiles = [...input.discoveredEntries.discoveredSteps].sort();
-    const stepFileSet = new Set(stepFiles);
-    const serdeOnlyFiles = [...input.discoveredEntries.discoveredSerdeFiles]
-        .sort()
-        .filter((filePath) => !stepFileSet.has(filePath));
-    const manifest = await collectNitroStepManifest({
-        projectRoot: input.projectRoot,
-        stepFiles,
-        serdeOnlyFiles,
-        workingDir: input.workingDir,
-    });
-    const outfileDirectory = dirname(input.outfile);
-    const builtinsImportSpecifier = input.builtinsPath === undefined
-        ? "workflow/internal/builtins"
-        : createFileImportSpecifier({
-            outfileDirectory,
-            preferAbsoluteFileImports: input.preferAbsoluteFileImports ?? false,
-            targetPath: input.builtinsPath,
-        });
-    const importLines = createEntrypointImportLines({
-        builtinsImportSpecifier,
-        outfileDirectory,
-        preferAbsoluteFileImports: input.preferAbsoluteFileImports ?? false,
-        serdeOnlyFiles,
-        stepFiles,
-    });
-    const lines = [
-        "// Generated by Ash. Do not edit by hand.",
-        ...importLines,
-        "export const __steps_registered = true;",
-        "",
-    ];
-    const nextSource = lines.join("\n");
-    await mkdir(outfileDirectory, { recursive: true });
-    const existingSource = await readTextFileIfPresent(input.outfile);
-    if (existingSource !== nextSource) {
-        await writeFile(input.outfile, nextSource);
-    }
-    return manifest;
-}
-function createEntrypointImportLines(input) {
-    const importedModules = [
-        input.builtinsImportSpecifier,
-        ...input.stepFiles.map((filePath) => createFileImportSpecifier({
-            outfileDirectory: input.outfileDirectory,
-            preferAbsoluteFileImports: input.preferAbsoluteFileImports,
-            targetPath: filePath,
-        })),
-        ...input.serdeOnlyFiles.map((filePath) => createFileImportSpecifier({
-            outfileDirectory: input.outfileDirectory,
-            preferAbsoluteFileImports: input.preferAbsoluteFileImports,
-            targetPath: filePath,
-        })),
-    ];
-    return importedModules.map((importSpecifier) => `import ${JSON.stringify(importSpecifier)};`);
-}
-function createFileImportSpecifier(input) {
-    if (input.preferAbsoluteFileImports) {
-        return normalizeEsmImportSpecifier(input.targetPath);
-    }
-    return createRelativeImportSpecifier(input.outfileDirectory, input.targetPath);
-}
-async function collectNitroStepManifest(input) {
-    const manifest = {};
-    const files = [...input.stepFiles, ...input.serdeOnlyFiles];
-    for (const filePath of files) {
-        const source = await readFile(filePath, "utf8");
-        const relativeFilepath = createManifestRelativeFilepath(input.workingDir, filePath);
-        const transformed = await applyWorkflowTransform(relativeFilepath, source, "step", filePath, input.projectRoot);
-        mergeWorkflowManifest(manifest, transformed.workflowManifest);
-    }
-    return manifest;
-}
-function mergeWorkflowManifest(target, source) {
-    target.steps = mergeWorkflowManifestSection(target.steps, source.steps);
-    target.workflows = mergeWorkflowManifestSection(target.workflows, source.workflows);
-    target.classes = mergeWorkflowManifestSection(target.classes, source.classes);
-}
-function mergeWorkflowManifestSection(target, source) {
-    if (source === undefined) {
-        return target;
-    }
-    const nextSection = {
-        ...target,
-    };
-    for (const [relativeFileName, entries] of Object.entries(source)) {
-        nextSection[relativeFileName] = {
-            ...nextSection[relativeFileName],
-            ...entries,
-        };
-    }
-    return nextSection;
-}
-function createManifestRelativeFilepath(workingDir, absolutePath) {
-    const normalizedFile = absolutePath.replaceAll("\\", "/");
-    const normalizedWorkingDir = workingDir.replaceAll("\\", "/");
-    let relativePath = relative(normalizedWorkingDir, normalizedFile).replaceAll("\\", "/");
-    if (relativePath.startsWith("../")) {
-        relativePath = relativePath
-            .split("/")
-            .filter((part) => part !== "..")
-            .join("/");
-    }
-    return relativePath;
-}
-function createRelativeImportSpecifier(fromDirectoryPath, targetPath) {
-    const relativePath = relative(fromDirectoryPath, targetPath).replaceAll("\\", "/");
-    if (relativePath.startsWith(".")) {
-        return relativePath;
-    }
-    return `./${relativePath}`;
-}
-async function readTextFileIfPresent(filePath) {
-    try {
-        return await readFile(filePath, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
+import{dirname,relative}from"node:path";import{mkdir,readFile,writeFile}from"node:fs/promises";import{normalizeEsmImportSpecifier}from"#internal/application/import-specifier.js";import{applyWorkflowTransform}from"#internal/workflow-bundle/workflow-builders.js";async function writeNitroStepEntrypoint(t){let r=[...t.discoveredEntries.discoveredSteps].sort(),a=new Set(r),o=[...t.discoveredEntries.discoveredSerdeFiles].sort().filter(e=>!a.has(e)),s=await collectNitroStepManifest({projectRoot:t.projectRoot,stepFiles:r,serdeOnlyFiles:o,workingDir:t.workingDir}),c=dirname(t.outfile),l=[`// Generated by Ash. Do not edit by hand.`,...createEntrypointImportLines({builtinsImportSpecifier:t.builtinsPath===void 0?`workflow/internal/builtins`:createFileImportSpecifier({outfileDirectory:c,preferAbsoluteFileImports:t.preferAbsoluteFileImports??!1,targetPath:t.builtinsPath}),outfileDirectory:c,preferAbsoluteFileImports:t.preferAbsoluteFileImports??!1,serdeOnlyFiles:o,stepFiles:r}),`export const __steps_registered = true;`,``].join(`
+`);return await mkdir(c,{recursive:!0}),await readTextFileIfPresent(t.outfile)!==l&&await writeFile(t.outfile,l),s}function createEntrypointImportLines(e){return[e.builtinsImportSpecifier,...e.stepFiles.map(t=>createFileImportSpecifier({outfileDirectory:e.outfileDirectory,preferAbsoluteFileImports:e.preferAbsoluteFileImports,targetPath:t})),...e.serdeOnlyFiles.map(t=>createFileImportSpecifier({outfileDirectory:e.outfileDirectory,preferAbsoluteFileImports:e.preferAbsoluteFileImports,targetPath:t}))].map(e=>`import ${JSON.stringify(e)};`)}function createFileImportSpecifier(e){return e.preferAbsoluteFileImports?normalizeEsmImportSpecifier(e.targetPath):createRelativeImportSpecifier(e.outfileDirectory,e.targetPath)}async function collectNitroStepManifest(e){let t={},n=[...e.stepFiles,...e.serdeOnlyFiles];for(let i of n){let n=await readFile(i,`utf8`);mergeWorkflowManifest(t,(await applyWorkflowTransform(createManifestRelativeFilepath(e.workingDir,i),n,`step`,i,e.projectRoot)).workflowManifest)}return t}function mergeWorkflowManifest(e,t){e.steps=mergeWorkflowManifestSection(e.steps,t.steps),e.workflows=mergeWorkflowManifestSection(e.workflows,t.workflows),e.classes=mergeWorkflowManifestSection(e.classes,t.classes)}function mergeWorkflowManifestSection(e,t){if(t===void 0)return e;let n={...e};for(let[e,r]of Object.entries(t))n[e]={...n[e],...r};return n}function createManifestRelativeFilepath(e,n){let r=n.replaceAll(`\\`,`/`),i=relative(e.replaceAll(`\\`,`/`),r).replaceAll(`\\`,`/`);return i.startsWith(`../`)&&(i=i.split(`/`).filter(e=>e!==`..`).join(`/`)),i}function createRelativeImportSpecifier(e,n){let r=relative(e,n).replaceAll(`\\`,`/`);return r.startsWith(`.`)?r:`./${r}`}async function readTextFileIfPresent(e){try{return await readFile(e,`utf8`)}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return null;throw e}}export{writeNitroStepEntrypoint};