@pikku/cli 0.12.15 → 0.12.16

package/dist/src/deploy/build-pipeline.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared build pipeline for deploy plan and apply.
+ *
+ * Runs: analyze → per-unit codegen → entry generation → bundle → configs
+ * Outputs everything to .deploy/<provider>/ without deploying.
+ */
+import type { InspectorState } from '@pikku/inspector';
+import type { DeploymentManifest } from './analyzer/manifest.js';
+import type { BundleResult } from './bundler/index.js';
+import type { ProviderAdapter } from './provider-adapter.js';
+export interface BuildLogger {
+    info(msg: string): void;
+    error(msg: string): void;
+    debug(msg: string): void;
+}
+export interface BuildPipelineResult {
+    manifest: DeploymentManifest;
+    providerDir: string;
+    projectId: string;
+    bundled: BundleResult[];
+    bundleErrors: Array<{
+        unitName: string;
+        error: string;
+    }>;
+    codegenErrors: Array<{
+        unitName: string;
+        error: string;
+    }>;
+}
+export declare function runBuildPipeline(options: {
+    projectDir: string;
+    projectId: string;
+    provider: ProviderAdapter;
+    inspectorState: InspectorState;
+    serverlessIncompatible?: string[];
+    getEntryContext: (unitDir: string, pikkuDir: string, unit: DeploymentManifest['units'][0], state: InspectorState) => unknown;
+    deployDir?: string;
+    logger: BuildLogger;
+}): Promise<BuildPipelineResult>;

package/dist/src/deploy/build-pipeline.js

@@ -0,0 +1,209 @@
+/**
+ * Shared build pipeline for deploy plan and apply.
+ *
+ * Runs: analyze → per-unit codegen → entry generation → bundle → configs
+ * Outputs everything to .deploy/<provider>/ without deploying.
+ */
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile, copyFile } from 'node:fs/promises';
+import { analyzeDeployment } from './analyzer/index.js';
+import { generatePerUnitCodegen } from './codegen/per-unit-codegen.js';
+import { bundleUnits } from './bundler/index.js';
+function findLockfile(projectDir) {
+    for (const name of ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml']) {
+        const p = join(projectDir, name);
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+export async function runBuildPipeline(options) {
+    const { projectDir, projectId, provider, inspectorState, getEntryContext, logger, } = options;
+    const deployDir = options.deployDir ?? join(projectDir, '.deploy');
+    const providerDir = join(deployDir, provider.deployDirName);
+    // Step 1: Analyze
+    const manifest = analyzeDeployment(inspectorState, {
+        projectId,
+        serverlessIncompatible: options.serverlessIncompatible,
+    });
+    let bundled = [];
+    let bundleErrors = [];
+    let codegenErrors = [];
+    if (provider.singleUnit) {
+        // Single-unit mode: bundle everything into one unit, use project's .pikku/ directly
+        logger.info('Building standalone bundle...');
+        const unitName = projectId;
+        const singleUnit = {
+            name: unitName,
+            role: 'function',
+            target: 'serverless',
+            functionIds: Object.keys(inspectorState.functions.meta),
+            services: [],
+            dependsOn: [],
+            handlers: [],
+            tags: [],
+        };
+        manifest.units = [singleUnit];
+        const unitDir = join(providerDir, unitName);
+        const pikkuDir = join(projectDir, '.pikku');
+        await mkdir(unitDir, { recursive: true });
+        const ctx = getEntryContext(unitDir, pikkuDir, singleUnit, inspectorState);
+        const source = provider.generateEntrySource(ctx);
+        const entryPath = join(unitDir, 'entry.ts');
+        await writeFile(entryPath, source, 'utf-8');
+        const entryFiles = new Map();
+        entryFiles.set(unitName, entryPath);
+        const bundleResult = await bundleUnits(projectDir, manifest, entryFiles, providerDir, {
+            externals: provider.getExternals?.(),
+            aliases: provider.getAliases?.(),
+            define: provider.getDefine?.(),
+            platform: provider.getPlatform?.(),
+            format: provider.getFormat?.(),
+        });
+        bundled = bundleResult.results;
+        bundleErrors = bundleResult.errors;
+        logger.info(`Bundled standalone${bundleErrors.length > 0 ? ` (${bundleErrors.length} errors)` : ''}`);
+    }
+    else {
+        // Multi-unit mode: per-function decomposition
+        const serverlessUnits = manifest.units.filter((u) => u.target === 'serverless');
+        const serverUnits = manifest.units.filter((u) => u.target === 'server');
+        logger.info(`Found ${manifest.units.length} units (${serverlessUnits.length} serverless, ${serverUnits.length} server), ${manifest.queues.length} queues, ${manifest.scheduledTasks.length} scheduled tasks`);
+        if (manifest.units.length === 0) {
+            return {
+                manifest,
+                providerDir,
+                projectId,
+                bundled: [],
+                bundleErrors: [],
+                codegenErrors: [],
+            };
+        }
+        // Step 2: Per-unit filtered codegen (serverless units only)
+        // Server units share a single codegen pass (step 2b).
+        const serverlessManifest = { ...manifest, units: serverlessUnits };
+        logger.info('Generating per-unit codegen...');
+        const { unitPikkuDirs, errors: serverlessCodegenErrors } = await generatePerUnitCodegen({
+            projectDir,
+            manifest: serverlessManifest,
+            inspectorState,
+            deployDir: providerDir,
+            onProgress: (unitName, status, error) => {
+                if (status === 'start') {
+                    logger.info(`  Codegen: ${unitName}...`);
+                }
+                else if (status === 'done') {
+                    logger.info(`  Codegen: ${unitName} done`);
+                }
+                else if (status === 'error') {
+                    logger.error(`  Codegen: ${unitName} failed — ${error}`);
+                }
+            },
+        });
+        codegenErrors = serverlessCodegenErrors;
+        // Step 2b: Server units — single codegen pass with all server function IDs
+        if (serverUnits.length > 0) {
+            const serverUnitName = 'server';
+            // Create a merged server unit with all server function IDs
+            const mergedServerUnit = {
+                name: serverUnitName,
+                role: 'function',
+                target: 'server',
+                functionIds: serverUnits.flatMap((u) => u.functionIds),
+                services: [],
+                dependsOn: [],
+                handlers: serverUnits.flatMap((u) => u.handlers),
+                tags: [],
+            };
+            // Run per-unit codegen for the merged server unit (tree-shakes to only server functions)
+            const serverManifest = { ...manifest, units: [mergedServerUnit] };
+            const { unitPikkuDirs: serverPikkuDirs, errors: serverCodegenErrors } = await generatePerUnitCodegen({
+                projectDir,
+                manifest: serverManifest,
+                inspectorState,
+                deployDir: providerDir,
+                onProgress: (unitName, status, error) => {
+                    if (status === 'start')
+                        logger.info(`  Codegen: ${unitName}...`);
+                    else if (status === 'done')
+                        logger.info(`  Codegen: ${unitName} done`);
+                    else if (status === 'error')
+                        logger.error(`  Codegen: ${unitName} failed — ${error}`);
+                },
+            });
+            for (const [k, v] of serverPikkuDirs)
+                unitPikkuDirs.set(k, v);
+            codegenErrors.push(...serverCodegenErrors);
+            // Replace individual server units with the merged one in the manifest
+            manifest.units = [...serverlessUnits, mergedServerUnit];
+            logger.info(`  Server container: ${serverUnits.length} functions merged into one unit`);
+        }
+        logger.info(`Codegen complete: ${unitPikkuDirs.size} units`);
+        // Step 3: Generate entry points + Bundle
+        logger.info('Bundling...');
+        const entryFiles = new Map();
+        for (const unit of manifest.units) {
+            const pikkuDir = unitPikkuDirs.get(unit.name);
+            if (!pikkuDir)
+                continue;
+            const unitDir = join(providerDir, unit.name);
+            const entryPath = join(unitDir, 'entry.ts');
+            await mkdir(unitDir, { recursive: true });
+            const ctx = getEntryContext(unitDir, pikkuDir, unit, inspectorState);
+            const source = provider.generateEntrySource(ctx);
+            await writeFile(entryPath, source, 'utf-8');
+            entryFiles.set(unit.name, entryPath);
+        }
+        const bundleResult = await bundleUnits(projectDir, manifest, entryFiles, providerDir, {
+            externals: provider.getExternals?.(),
+            aliases: provider.getAliases?.(),
+            define: provider.getDefine?.(),
+            platform: provider.getPlatform?.(),
+            format: provider.getFormat?.(),
+        });
+        bundled = bundleResult.results;
+        bundleErrors = bundleResult.errors;
+        logger.info(`Bundled ${bundled.length} units${bundleErrors.length > 0 ? ` (${bundleErrors.length} failed)` : ''}`);
+    }
+    if (bundleErrors.length > 0) {
+        for (const f of bundleErrors) {
+            logger.error(`  Failed: ${f.unitName} — ${f.error}`);
+        }
+    }
+    // Step 4: Generate configs + infra manifest
+    const infraContent = provider.generateInfraManifest(manifest);
+    if (infraContent) {
+        await writeFile(join(providerDir, 'infra.json'), infraContent, 'utf-8');
+        logger.info('Generated infrastructure manifest');
+    }
+    if (provider.generateProviderConfigs) {
+        const providerConfigs = provider.generateProviderConfigs(manifest);
+        for (const [filename, content] of providerConfigs) {
+            const filePath = join(providerDir, filename);
+            await mkdir(join(filePath, '..'), { recursive: true });
+            await writeFile(filePath, content, 'utf-8');
+        }
+    }
+    const lockfileSrc = findLockfile(projectDir);
+    for (const unit of manifest.units) {
+        const unitDir = join(providerDir, unit.name);
+        await mkdir(unitDir, { recursive: true });
+        const configs = provider.generateUnitConfigs(unit, manifest, projectId);
+        for (const [filename, content] of configs) {
+            await writeFile(join(unitDir, filename), content, 'utf-8');
+        }
+        if (lockfileSrc) {
+            await copyFile(lockfileSrc, join(unitDir, 'yarn.lock'));
+        }
+    }
+    logger.info(`Generated ${manifest.units.length} provider config files`);
+    return {
+        manifest,
+        providerDir,
+        projectId,
+        bundled,
+        bundleErrors,
+        codegenErrors,
+    };
+}

package/dist/src/deploy/bundler/bundler.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Main esbuild bundling pipeline for Pikku.
+ *
+ * For each deployment unit in a DeploymentManifest, this module:
+ * 1. Takes a pre-generated entry point (provided by the deploy provider)
+ * 2. Runs esbuild with bundle:true, npm packages external
+ * 3. Stubs Node.js-only gen files that aren't needed by this unit
+ * 4. Parses the metafile to extract external dependencies
+ * 5. Generates a minimal package.json with exact versions
+ * 6. Writes all artifacts to `<outputDir>/<unit-name>/`
+ */
+import type { DeploymentManifest, BundleOutput } from './types.js';
+/**
+ * Bundles all deployment units defined in a DeploymentManifest.
+ *
+ * Entry points must be pre-generated by the provider-specific package
+ * (e.g. @pikku/deploy-cloudflare) and passed in as entryFiles.
+ *
+ * @param projectDir - Root directory of the Pikku project
+ * @param manifest - The deployment manifest describing all units
+ * @param entryFiles - Map of unit name -> entry file path (generated by the deploy provider)
+ * @param outputDir - Base output directory (defaults to `<projectDir>/.deploy/build`)
+ */
+export declare function bundleUnits(projectDir: string, manifest: DeploymentManifest, entryFiles: Map<string, string>, outputDir?: string, options?: {
+    externals?: string[];
+    aliases?: Record<string, string>;
+    define?: Record<string, string>;
+    platform?: 'node' | 'neutral' | 'browser';
+    format?: 'esm' | 'cjs';
+}): Promise<BundleOutput>;

package/dist/src/deploy/bundler/bundler.js

@@ -0,0 +1,196 @@
+/**
+ * Main esbuild bundling pipeline for Pikku.
+ *
+ * For each deployment unit in a DeploymentManifest, this module:
+ * 1. Takes a pre-generated entry point (provided by the deploy provider)
+ * 2. Runs esbuild with bundle:true, npm packages external
+ * 3. Stubs Node.js-only gen files that aren't needed by this unit
+ * 4. Parses the metafile to extract external dependencies
+ * 5. Generates a minimal package.json with exact versions
+ * 6. Writes all artifacts to `<outputDir>/<unit-name>/`
+ */
+import { build } from 'esbuild';
+import { writeFile, mkdir, stat, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { extractDependencies, generateMinimalPackageJson, } from './dep-extractor.js';
+/**
+ * Mapping of service name -> gen file pattern that should be stubbed
+ * when the service is not required by a deployment unit.
+ */
+const SERVICE_GEN_FILE_MAP = {
+    metaService: /pikku-meta-service\.gen/,
+};
+/**
+ * Read the per-unit pikku-services.gen.ts and return the set of gen file
+ * patterns that should be stubbed (because their service is not required).
+ */
+async function getDeadGenFilePatterns(unitOutputDir) {
+    const patterns = [];
+    try {
+        const servicesPath = join(unitOutputDir, '.pikku', 'pikku-services.gen.ts');
+        const content = await readFile(servicesPath, 'utf-8');
+        const match = content.match(/export const requiredSingletonServices = \{([^}]+)\}/);
+        if (match) {
+            for (const line of match[1].split('\n')) {
+                const kv = line.match(/'([^']+)':\s*false/);
+                if (kv && SERVICE_GEN_FILE_MAP[kv[1]]) {
+                    patterns.push(SERVICE_GEN_FILE_MAP[kv[1]]);
+                }
+            }
+        }
+    }
+    catch {
+        // No services gen — no stubs needed
+    }
+    return patterns;
+}
+/**
+ * esbuild plugin that stubs gen files for services not needed by this unit.
+ * This prevents Node.js-only modules (e.g. LocalMetaService which uses fs)
+ * from being pulled into serverless worker bundles via dynamic imports.
+ */
+function createDeadModuleStubPlugin(patterns) {
+    return {
+        name: 'pikku-dead-module-stub',
+        setup(build) {
+            if (patterns.length === 0)
+                return;
+            const combined = new RegExp(patterns.map((p) => p.source).join('|'));
+            build.onResolve({ filter: combined }, (args) => ({
+                path: args.path,
+                namespace: 'pikku-stub',
+            }));
+            build.onLoad({ filter: /.*/, namespace: 'pikku-stub' }, () => ({
+                contents: 'export {}',
+                loader: 'js',
+            }));
+        },
+    };
+}
+const BUNDLE_FILENAME = 'bundle.js';
+const METAFILE_FILENAME = 'metafile.json';
+const PACKAGE_JSON_FILENAME = 'package.json';
+/**
+ * Bundles a single deployment unit using esbuild.
+ *
+ * Produces three files in the unit output directory:
+ * - bundle.js: The bundled code (user code only, external deps as bare imports)
+ * - metafile.json: esbuild's metafile for analysis
+ * - package.json: Minimal manifest with only the external deps this unit needs
+ */
+async function bundleUnit(options) {
+    const { unit, entryPath, unitOutputDir, projectDir, externals, aliases, define, platform, format, } = options;
+    await mkdir(unitOutputDir, { recursive: true });
+    const bundlePath = join(unitOutputDir, BUNDLE_FILENAME);
+    const metafilePath = join(unitOutputDir, METAFILE_FILENAME);
+    const packageJsonPath = join(unitOutputDir, PACKAGE_JSON_FILENAME);
+    // Determine which gen files to stub based on per-unit service requirements
+    const deadPatterns = await getDeadGenFilePatterns(unitOutputDir);
+    // Run esbuild — inline everything into a self-contained bundle.
+    // Only Node built-ins are kept external (CF Workers provides them).
+    // The stub plugin replaces gen files for unused services with empty
+    // modules, preventing Node.js-only code from entering the bundle.
+    // Resolve node_modules paths up the directory tree for workspace packages
+    const nodePaths = [];
+    let dir = projectDir;
+    while (true) {
+        const nm = join(dir, 'node_modules');
+        nodePaths.push(nm);
+        const parent = join(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // For ESM + node platform, CJS deps may use require() for builtins.
+    // esbuild wraps these as __require() which fails at runtime in ESM.
+    // The banner shims require via createRequire so CJS builtins resolve.
+    const resolvedFormat = format ?? 'esm';
+    const banner = resolvedFormat === 'esm' && (platform ?? 'node') === 'node'
+        ? { js: `import { createRequire } from 'module'; const require = createRequire(import.meta.url);` }
+        : undefined;
+    const result = await build({
+        entryPoints: [entryPath],
+        bundle: true,
+        absWorkingDir: projectDir,
+        nodePaths,
+        platform: platform ?? 'node',
+        format: resolvedFormat,
+        banner,
+        metafile: true,
+        target: 'es2022',
+        outfile: bundlePath,
+        minify: false,
+        sourcemap: true,
+        logLevel: 'warning',
+        loader: { '.ts': 'ts' },
+        external: externals ?? ['node:*'],
+        alias: aliases,
+        define,
+        plugins: [createDeadModuleStubPlugin(deadPatterns)],
+    });
+    // Write metafile
+    const metafileJson = JSON.stringify(result.metafile, null, 2);
+    await writeFile(metafilePath, metafileJson, 'utf-8');
+    // Extract dependencies and generate minimal package.json
+    const dependencies = await extractDependencies(result.metafile, projectDir);
+    const packageJson = generateMinimalPackageJson(unit.name, dependencies);
+    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
+    // Get bundle size
+    const bundleStat = await stat(bundlePath);
+    return {
+        unitName: unit.name,
+        bundlePath,
+        packageJsonPath,
+        metafilePath,
+        bundleSizeBytes: bundleStat.size,
+        externalPackages: dependencies,
+    };
+}
+/**
+ * Bundles all deployment units defined in a DeploymentManifest.
+ *
+ * Entry points must be pre-generated by the provider-specific package
+ * (e.g. @pikku/deploy-cloudflare) and passed in as entryFiles.
+ *
+ * @param projectDir - Root directory of the Pikku project
+ * @param manifest - The deployment manifest describing all units
+ * @param entryFiles - Map of unit name -> entry file path (generated by the deploy provider)
+ * @param outputDir - Base output directory (defaults to `<projectDir>/.deploy/build`)
+ */
+export async function bundleUnits(projectDir, manifest, entryFiles, outputDir, options) {
+    const buildDir = outputDir ?? join(projectDir, '.deploy', 'build');
+    const results = [];
+    const errors = [];
+    if (manifest.units.length === 0) {
+        return { results, errors };
+    }
+    for (const unit of manifest.units) {
+        const entryPath = entryFiles.get(unit.name);
+        if (!entryPath) {
+            errors.push({
+                unitName: unit.name,
+                error: `No entry point provided for unit "${unit.name}"`,
+            });
+            continue;
+        }
+        const unitOutputDir = join(buildDir, unit.name);
+        try {
+            const result = await bundleUnit({
+                unit,
+                entryPath,
+                unitOutputDir,
+                projectDir,
+                ...options,
+            });
+            results.push(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            errors.push({
+                unitName: unit.name,
+                error: message,
+            });
+        }
+    }
+    return { results, errors };
+}

package/dist/src/deploy/bundler/dep-extractor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Extracts external dependency information from esbuild metafiles.
+ *
+ * Parses esbuild's metafile JSON to find all node_modules references,
+ * then resolves their exact versions from the project's package.json
+ * and/or yarn.lock to produce a minimal package.json.
+ */
+import type { Metafile } from 'esbuild';
+/**
+ * Extracts bare package names from esbuild metafile imports.
+ *
+ * When esbuild runs with `packages: 'external'`, external imports appear
+ * in the metafile's outputs[].imports array with `external: true`.
+ * This function collects all unique package names from those imports.
+ */
+export declare function extractExternalPackages(metafile: Metafile): Set<string>;
+/**
+ * Parses a bare import specifier into a package name.
+ *
+ * Handles scoped packages (`@scope/pkg`) and deep imports (`pkg/sub/path`).
+ * Returns null for relative imports or other non-package specifiers.
+ */
+export declare function parsePackageName(specifier: string): string | null;
+/**
+ * Given an esbuild metafile, extracts all external packages and resolves
+ * their versions from the project's dependency files.
+ *
+ * Returns a record of package name to exact version, suitable for
+ * writing into a minimal package.json.
+ */
+export declare function extractDependencies(metafile: Metafile, projectDir: string): Promise<Record<string, string>>;
+/**
+ * Generates a minimal package.json content object for a unit bundle.
+ */
+export declare function generateMinimalPackageJson(unitName: string, dependencies: Record<string, string>): Record<string, unknown>;