@b9g/shovel 0.2.0-beta.10 → 0.2.0-beta.11

package/build-NDUV2F2Z.js

@@ -1,386 +0,0 @@
-import {
-  applyJSXOptions,
-  importMetaPlugin,
-  loadJSXConfig
-} from "./chunk-ILQUUH2L.js";
-import {
-  findProjectRoot,
-  findWorkspaceRoot,
-  generateConfigModule,
-  getNodeModulesPath,
-  loadRawConfig
-} from "./chunk-CSH7M4MK.js";
-
-// src/commands/build.ts
-import * as ESBuild from "esbuild";
-import { resolve, join, dirname } from "path";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { assetsPlugin } from "@b9g/assets/plugin";
-import { getLogger } from "@logtape/logtape";
-import * as Platform from "@b9g/platform";
-var logger = getLogger(["cli"]);
-function validateDynamicImports(result, context) {
-  const dynamicImportWarnings = (result.warnings || []).filter(
-    (w) => w.text.includes("cannot be bundled") || w.text.includes("import() call") || w.text.includes("dynamic import")
-  );
-  if (dynamicImportWarnings.length > 0) {
-    const locations = dynamicImportWarnings.map((w) => {
-      const loc = w.location;
-      const file = loc?.file || "unknown";
-      const line = loc?.line || "?";
-      return `  ${file}:${line} - ${w.text}`;
-    }).join("\n");
-    throw new Error(
-      `Build failed (${context}): Non-analyzable dynamic imports found:
-${locations}
-
-Dynamic imports must use literal strings, not variables.
-For config-driven providers, ensure they are registered in shovel.json.`
-    );
-  }
-}
-var BUILD_DEFAULTS = {
-  format: "esm",
-  target: "es2022",
-  outputFile: "index.js",
-  sourcemap: false,
-  minify: false,
-  treeShaking: true
-};
-var BUILD_STRUCTURE = {
-  serverDir: "server",
-  staticDir: "static"
-};
-function createConfigPlugin(projectRoot) {
-  const rawConfig = loadRawConfig(projectRoot);
-  const configModuleCode = generateConfigModule(rawConfig);
-  return {
-    name: "shovel-config",
-    setup(build2) {
-      build2.onResolve({ filter: /^shovel:config$/ }, (args) => ({
-        path: args.path,
-        namespace: "shovel-config"
-      }));
-      build2.onLoad({ filter: /.*/, namespace: "shovel-config" }, () => ({
-        contents: configModuleCode,
-        loader: "js",
-        resolveDir: projectRoot
-      }));
-    }
-  };
-}
-async function buildForProduction({
-  entrypoint,
-  outDir,
-  verbose,
-  platform = "node",
-  workerCount = 1
-}) {
-  const buildContext = await initializeBuild({
-    entrypoint,
-    outDir,
-    verbose,
-    platform,
-    workerCount
-  });
-  const buildConfig = await createBuildConfig(buildContext);
-  const result = await ESBuild.build(buildConfig);
-  validateDynamicImports(result, "main bundle");
-  if (verbose && result.metafile) {
-    await logBundleAnalysis(result.metafile);
-  }
-  await generatePackageJSON({
-    ...buildContext,
-    entryPath: buildContext.entryPath
-  });
-  if (verbose) {
-    logger.info("Built app to", { outputDir: buildContext.outputDir });
-    logger.info("Server files", { dir: buildContext.serverDir });
-    logger.info("Static files", { dir: join(buildContext.outputDir, "static") });
-  }
-}
-async function initializeBuild({
-  entrypoint,
-  outDir,
-  verbose,
-  platform,
-  workerCount = 1
-}) {
-  if (!entrypoint) {
-    throw new Error("Entry point is required");
-  }
-  if (!outDir) {
-    throw new Error("Output directory is required");
-  }
-  if (verbose) {
-    logger.info("Entry:", { path: entrypoint });
-    logger.info("Output:", { dir: outDir });
-    logger.info("Target platform:", { platform });
-  }
-  const entryPath = resolve(entrypoint);
-  const outputDir = resolve(outDir);
-  try {
-    const stats = await readFile(entryPath, "utf8");
-    if (stats.length === 0) {
-      logger.warn("Entry point is empty", { entryPath });
-    }
-  } catch (error) {
-    throw new Error(`Entry point not found or not accessible: ${entryPath}`);
-  }
-  const validPlatforms = ["node", "bun", "cloudflare", "cloudflare-workers"];
-  if (!validPlatforms.includes(platform)) {
-    throw new Error(
-      `Invalid platform: ${platform}. Valid platforms: ${validPlatforms.join(", ")}`
-    );
-  }
-  const projectRoot = findProjectRoot();
-  if (verbose) {
-    logger.info("Entry:", { entryPath });
-    logger.info("Output:", { outputDir });
-    logger.info("Target platform:", { platform });
-    logger.info("Project root:", { projectRoot });
-  }
-  try {
-    await mkdir(outputDir, { recursive: true });
-    await mkdir(join(outputDir, BUILD_STRUCTURE.serverDir), { recursive: true });
-    await mkdir(join(outputDir, BUILD_STRUCTURE.staticDir), { recursive: true });
-  } catch (error) {
-    throw new Error(`Failed to create output directory structure: ${error}`);
-  }
-  return {
-    entryPath,
-    outputDir,
-    serverDir: join(outputDir, BUILD_STRUCTURE.serverDir),
-    projectRoot,
-    platform,
-    verbose,
-    workerCount
-  };
-}
-async function createBuildConfig({
-  entryPath,
-  outputDir,
-  serverDir,
-  projectRoot,
-  platform: platformName
-}) {
-  const platform = await Platform.createPlatform(platformName);
-  const platformEsbuildConfig = platform.getEsbuildConfig();
-  const entryWrapper = platform.getEntryWrapper(entryPath);
-  const bundlesUserCodeInline = platformEsbuildConfig.bundlesUserCodeInline ?? false;
-  const jsxOptions = await loadJSXConfig(projectRoot || dirname(entryPath));
-  try {
-    const external = platformEsbuildConfig.external ?? ["node:*"];
-    if (!bundlesUserCodeInline) {
-      const userBuildConfig = {
-        entryPoints: [entryPath],
-        bundle: true,
-        format: BUILD_DEFAULTS.format,
-        target: BUILD_DEFAULTS.target,
-        platform: platformEsbuildConfig.platform ?? "node",
-        outfile: join(serverDir, "server.js"),
-        absWorkingDir: projectRoot,
-        mainFields: ["module", "main"],
-        conditions: platformEsbuildConfig.conditions ?? ["import", "module"],
-        // Resolve packages from the user's project node_modules
-        nodePaths: [getNodeModulesPath()],
-        plugins: [
-          importMetaPlugin(),
-          assetsPlugin({
-            outDir: outputDir,
-            clientBuild: {
-              jsx: jsxOptions.jsx,
-              jsxFactory: jsxOptions.jsxFactory,
-              jsxFragment: jsxOptions.jsxFragment,
-              jsxImportSource: jsxOptions.jsxImportSource
-            }
-          })
-        ],
-        metafile: true,
-        sourcemap: BUILD_DEFAULTS.sourcemap,
-        minify: BUILD_DEFAULTS.minify,
-        treeShaking: BUILD_DEFAULTS.treeShaking,
-        define: platformEsbuildConfig.define ?? {},
-        external
-      };
-      applyJSXOptions(userBuildConfig, jsxOptions);
-      const userBuildResult = await ESBuild.build(userBuildConfig);
-      validateDynamicImports(userBuildResult, "user code");
-      const workerDestPath = join(serverDir, "worker.js");
-      const virtualWorkerEntry = `
-import {configureLogging} from "@b9g/platform/runtime";
-import {config} from "shovel:config";
-await configureLogging(config.logging);
-
-// Import the actual worker (runs its initialization code)
-import "@b9g/platform/worker";
-`;
-      await ESBuild.build({
-        stdin: {
-          contents: virtualWorkerEntry,
-          resolveDir: projectRoot,
-          sourcefile: "virtual-worker-entry.js"
-        },
-        bundle: true,
-        format: "esm",
-        target: "es2022",
-        platform: "node",
-        outfile: workerDestPath,
-        external: ["node:*"],
-        plugins: [createConfigPlugin(projectRoot)]
-      });
-    }
-    const buildConfig = {
-      stdin: {
-        contents: entryWrapper,
-        // Use serverDir so ./server.js resolves to the built user code
-        resolveDir: serverDir,
-        sourcefile: "virtual-entry.js"
-      },
-      bundle: true,
-      format: BUILD_DEFAULTS.format,
-      target: BUILD_DEFAULTS.target,
-      platform: platformEsbuildConfig.platform ?? "node",
-      // Inline bundling (Cloudflare): single-file (server.js contains everything)
-      // Separate bundling (Node/Bun): multi-file (index.js is entry, server.js is user code)
-      outfile: join(
-        serverDir,
-        bundlesUserCodeInline ? "server.js" : BUILD_DEFAULTS.outputFile
-      ),
-      absWorkingDir: projectRoot,
-      mainFields: ["module", "main"],
-      conditions: platformEsbuildConfig.conditions ?? ["import", "module"],
-      // Resolve packages from the user's project node_modules
-      nodePaths: [getNodeModulesPath()],
-      plugins: bundlesUserCodeInline ? [
-        createConfigPlugin(projectRoot),
-        importMetaPlugin(),
-        assetsPlugin({
-          outDir: outputDir,
-          clientBuild: {
-            jsx: jsxOptions.jsx,
-            jsxFactory: jsxOptions.jsxFactory,
-            jsxFragment: jsxOptions.jsxFragment,
-            jsxImportSource: jsxOptions.jsxImportSource
-          }
-        })
-      ] : [createConfigPlugin(projectRoot)],
-      // Config plugin needed for entry wrapper
-      metafile: true,
-      sourcemap: BUILD_DEFAULTS.sourcemap,
-      minify: BUILD_DEFAULTS.minify,
-      treeShaking: BUILD_DEFAULTS.treeShaking,
-      define: platformEsbuildConfig.define ?? {},
-      external
-    };
-    if (bundlesUserCodeInline) {
-      applyJSXOptions(buildConfig, jsxOptions);
-    }
-    return buildConfig;
-  } catch (error) {
-    throw new Error(`Failed to create build configuration: ${error}`);
-  }
-}
-async function logBundleAnalysis(metafile) {
-  try {
-    logger.info("Bundle analysis:", {});
-    const analysis = await ESBuild.analyzeMetafile(metafile);
-    logger.info(analysis, {});
-  } catch (error) {
-    logger.warn("Failed to analyze bundle: {error}", { error });
-  }
-}
-async function generatePackageJSON({
-  serverDir,
-  platform,
-  verbose,
-  entryPath
-}) {
-  const entryDir = dirname(entryPath);
-  const sourcePackageJsonPath = resolve(entryDir, "package.json");
-  try {
-    const packageJSONContent = await readFile(sourcePackageJsonPath, "utf8");
-    try {
-      JSON.parse(packageJSONContent);
-    } catch (parseError) {
-      throw new Error(`Invalid package.json format: ${parseError}`);
-    }
-    await writeFile(
-      join(serverDir, "package.json"),
-      packageJSONContent,
-      "utf8"
-    );
-    if (verbose) {
-      logger.info("Copied package.json", { serverDir });
-    }
-  } catch (error) {
-    if (verbose) {
-      logger.warn("Could not copy package.json: {error}", { error });
-    }
-    try {
-      const generatedPackageJson = await generateExecutablePackageJSON(platform);
-      await writeFile(
-        join(serverDir, "package.json"),
-        JSON.stringify(generatedPackageJson, null, 2),
-        "utf8"
-      );
-      if (verbose) {
-        logger.info("Generated package.json", { platform });
-        logger.info("Package.json contents", {
-          contents: JSON.stringify(generatedPackageJson, null, 2)
-        });
-      }
-    } catch (generateError) {
-      if (verbose) {
-        logger.warn("Could not generate package.json: {error}", {
-          error: generateError
-        });
-      }
-    }
-  }
-}
-async function generateExecutablePackageJSON(platform) {
-  const packageJSON = {
-    name: "shovel-executable",
-    version: "1.0.0",
-    type: "module",
-    private: true,
-    dependencies: {}
-  };
-  const isWorkspaceEnvironment = findWorkspaceRoot() !== null;
-  if (isWorkspaceEnvironment) {
-    packageJSON.dependencies = {};
-  } else {
-    switch (platform) {
-      case "node":
-        packageJSON.dependencies["@b9g/platform-node"] = "^0.1.0";
-        break;
-      case "bun":
-        packageJSON.dependencies["@b9g/platform-bun"] = "^0.1.0";
-        break;
-      case "cloudflare":
-        packageJSON.dependencies["@b9g/platform-cloudflare"] = "^0.1.0";
-        break;
-      default:
-        packageJSON.dependencies["@b9g/platform"] = "^0.1.0";
-    }
-    packageJSON.dependencies["@b9g/cache"] = "^0.1.0";
-    packageJSON.dependencies["@b9g/filesystem"] = "^0.1.0";
-  }
-  return packageJSON;
-}
-async function buildCommand(entrypoint, options, config) {
-  const platform = Platform.resolvePlatform({ ...options, config });
-  await buildForProduction({
-    entrypoint,
-    outDir: "dist",
-    verbose: options.verbose || false,
-    platform,
-    workerCount: options.workers ? parseInt(options.workers, 10) : config.workers
-  });
-  process.exit(0);
-}
-export {
-  buildCommand,
-  buildForProduction
-};