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

package/src/_chunks/build-V3IPZGKC.js

@@ -0,0 +1,434 @@
+import {
+  createConfigPlugin,
+  createEntryPlugin,
+  getGitSHA
+} from "./chunk-ADR5RW57.js";
+import {
+  applyJSXOptions,
+  assetsPlugin,
+  importMetaPlugin,
+  loadJSXConfig
+} from "./chunk-JJFM7PO2.js";
+import {
+  findProjectRoot,
+  findWorkspaceRoot,
+  getNodeModulesPath
+} from "./chunk-GRAFMTEH.js";
+
+// src/commands/build.ts
+import * as ESBuild from "esbuild";
+import { builtinModules, createRequire } from "node:module";
+import { resolve, join, dirname } from "path";
+import { getLogger } from "@logtape/logtape";
+import * as Platform from "@b9g/platform";
+import { mkdir, readFile, writeFile } from "fs/promises";
+var logger = getLogger(["shovel"]);
+function validateDynamicImports(result, context, excludePatterns = []) {
+  const dynamicImportWarnings = (result.warnings || []).filter(
+    (w) => (w.text.includes("cannot be bundled") || w.text.includes("import() call") || w.text.includes("dynamic import")) && // Exclude intentional dynamic imports
+    !excludePatterns.some((pattern) => w.text.includes(pattern))
+  );
+  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.`
+    );
+  }
+}
+function validateExternals(result, allowedExternals, context) {
+  if (!result.metafile)
+    return;
+  const allowedSet = new Set(allowedExternals);
+  const hasNodeWildcard = allowedExternals.includes("node:*");
+  const unexpectedExternals = [];
+  for (const path of Object.keys(result.metafile.inputs)) {
+    if (!path.startsWith("<external>:"))
+      continue;
+    const moduleName = path.slice("<external>:".length);
+    const isAllowed = allowedSet.has(moduleName) || hasNodeWildcard && moduleName.startsWith("node:") || builtinModules.includes(moduleName);
+    if (!isAllowed && !unexpectedExternals.includes(moduleName)) {
+      unexpectedExternals.push(moduleName);
+    }
+  }
+  if (unexpectedExternals.length > 0) {
+    const externals = unexpectedExternals.map((e) => `  - ${e}`).join("\n");
+    throw new Error(
+      `Build failed (${context}): Unexpected external imports found:
+${externals}
+
+These modules are not bundled and won't be available at runtime.
+Either bundle them or add them to the platform's external list.`
+    );
+  }
+}
+var BUILD_DEFAULTS = {
+  format: "esm",
+  target: "es2022",
+  outputFile: "index.js",
+  sourcemap: false,
+  minify: false,
+  treeShaking: true
+};
+var BUILD_STRUCTURE = {
+  serverDir: "server",
+  publicDir: "public"
+};
+async function buildForProduction({
+  entrypoint,
+  outDir,
+  platform = "node",
+  workerCount = 1,
+  userBuildConfig
+}) {
+  const buildContext = await initializeBuild({
+    entrypoint,
+    outDir,
+    platform,
+    workerCount
+  });
+  const buildConfig = await createBuildConfig({
+    entryPath: buildContext.entryPath,
+    outputDir: buildContext.outputDir,
+    serverDir: buildContext.serverDir,
+    projectRoot: buildContext.projectRoot,
+    platform: buildContext.platform,
+    shovelBuildConfig: userBuildConfig
+  });
+  const result = await ESBuild.build(buildConfig);
+  validateDynamicImports(result, "main bundle");
+  const external = buildConfig.external ?? ["node:*"];
+  validateExternals(result, external, "main bundle");
+  await generatePackageJSON({
+    ...buildContext,
+    entryPath: buildContext.entryPath
+  });
+  logger.debug("Built app to", { outputDir: buildContext.outputDir });
+  logger.debug("Server files", { dir: buildContext.serverDir });
+  logger.debug("Public files", { dir: join(buildContext.outputDir, "public") });
+}
+async function initializeBuild({
+  entrypoint,
+  outDir,
+  platform,
+  workerCount = 1
+}) {
+  if (!entrypoint) {
+    throw new Error("Entry point is required");
+  }
+  if (!outDir) {
+    throw new Error("Output directory is required");
+  }
+  logger.debug("Entry:", { path: entrypoint });
+  logger.debug("Output:", { dir: outDir });
+  logger.debug("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"];
+  if (!validPlatforms.includes(platform)) {
+    throw new Error(
+      `Invalid platform: ${platform}. Valid platforms: ${validPlatforms.join(", ")}`
+    );
+  }
+  const projectRoot = findProjectRoot(dirname(entryPath));
+  logger.debug("Entry:", { entryPath });
+  logger.debug("Output:", { outputDir });
+  logger.debug("Target platform:", { platform });
+  logger.debug("Project root:", { projectRoot });
+  try {
+    await mkdir(outputDir, { recursive: true });
+    await mkdir(join(outputDir, BUILD_STRUCTURE.serverDir), { recursive: true });
+    await mkdir(join(outputDir, BUILD_STRUCTURE.publicDir), { 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,
+    workerCount
+  };
+}
+async function loadUserPlugins(plugins, projectRoot) {
+  const loadedPlugins = [];
+  for (const pluginConfig of plugins) {
+    const {
+      module: modulePath,
+      export: exportName = "default",
+      ...options
+    } = pluginConfig;
+    try {
+      const projectRequire = createRequire(join(projectRoot, "package.json"));
+      const resolvedPath = modulePath.startsWith(".") ? resolve(projectRoot, modulePath) : projectRequire.resolve(modulePath);
+      const mod = await import(resolvedPath);
+      const pluginFactory = exportName === "default" ? mod.default : mod[exportName];
+      if (typeof pluginFactory !== "function") {
+        throw new Error(
+          `Plugin export "${exportName}" from "${modulePath}" is not a function`
+        );
+      }
+      const hasOptions = Object.keys(options).length > 0;
+      const plugin = hasOptions ? pluginFactory(options) : pluginFactory();
+      loadedPlugins.push(plugin);
+      logger.debug("Loaded ESBuild plugin", {
+        module: modulePath,
+        export: exportName
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to load ESBuild plugin "${modulePath}": ${error instanceof Error ? error.message : error}`
+      );
+    }
+  }
+  return loadedPlugins;
+}
+async function createBuildConfig({
+  entryPath,
+  outputDir,
+  serverDir,
+  projectRoot,
+  platform: platformName,
+  shovelBuildConfig
+}) {
+  const platform = await Platform.createPlatform(platformName);
+  const platformESBuildConfig = platform.getESBuildConfig();
+  const platformDefaults = platform.getDefaults();
+  const entryWrapper = platform.getEntryWrapper(entryPath);
+  const bundlesUserCodeInline = platformESBuildConfig.bundlesUserCodeInline ?? false;
+  const jsxOptions = await loadJSXConfig(projectRoot || dirname(entryPath));
+  const target = shovelBuildConfig?.target ?? BUILD_DEFAULTS.target;
+  const minify = shovelBuildConfig?.minify ?? BUILD_DEFAULTS.minify;
+  const sourcemap = shovelBuildConfig?.sourcemap ?? BUILD_DEFAULTS.sourcemap;
+  const treeShaking = shovelBuildConfig?.treeShaking ?? BUILD_DEFAULTS.treeShaking;
+  const userPlugins = shovelBuildConfig?.plugins?.length ? await loadUserPlugins(shovelBuildConfig.plugins, projectRoot) : [];
+  try {
+    const platformExternal = platformESBuildConfig.external ?? ["node:*"];
+    const userExternal = shovelBuildConfig?.external ?? [];
+    const external = [...platformExternal, ...userExternal];
+    if (!bundlesUserCodeInline) {
+      const workerEntryWrapper = platform.getEntryWrapper(
+        "./server.js",
+        // Relative import to sibling output file
+        { type: "worker", outDir: outputDir }
+      );
+      const workerBuildConfig = {
+        entryPoints: {
+          worker: "shovel:entry",
+          server: entryPath,
+          config: "shovel:config"
+        },
+        bundle: true,
+        format: BUILD_DEFAULTS.format,
+        target,
+        platform: platformESBuildConfig.platform ?? "node",
+        outdir: serverDir,
+        entryNames: "[name]",
+        absWorkingDir: projectRoot,
+        mainFields: ["module", "main"],
+        conditions: platformESBuildConfig.conditions ?? ["import", "module"],
+        // Resolve packages from the user's project node_modules
+        nodePaths: [getNodeModulesPath()],
+        // User plugins run first, then Shovel's core plugins
+        plugins: [
+          ...userPlugins,
+          createConfigPlugin(projectRoot, outputDir, { platformDefaults }),
+          createEntryPlugin(projectRoot, workerEntryWrapper),
+          importMetaPlugin(),
+          assetsPlugin({
+            outDir: outputDir,
+            clientBuild: {
+              jsx: jsxOptions.jsx,
+              jsxFactory: jsxOptions.jsxFactory,
+              jsxFragment: jsxOptions.jsxFragment,
+              jsxImportSource: jsxOptions.jsxImportSource
+            }
+          })
+        ],
+        metafile: true,
+        sourcemap,
+        minify,
+        treeShaking,
+        define: {
+          ...platformESBuildConfig.define ?? {},
+          // User-defined constants
+          ...shovelBuildConfig?.define ?? {},
+          // Inject output directory for runtime.outdir() resolution
+          __SHOVEL_OUTDIR__: JSON.stringify(outputDir),
+          // Inject git commit SHA for [git] placeholder
+          __SHOVEL_GIT__: JSON.stringify(getGitSHA(projectRoot))
+        },
+        // Path aliases from user config
+        alias: shovelBuildConfig?.alias,
+        // Mark ./server.js as external so it's imported at runtime (sibling output file)
+        external: [...external, "./server.js"]
+      };
+      applyJSXOptions(workerBuildConfig, jsxOptions);
+      const workerBuildResult = await ESBuild.build(workerBuildConfig);
+      validateDynamicImports(workerBuildResult, "worker bundle", [
+        "./server.js"
+      ]);
+      validateExternals(workerBuildResult, external, "worker bundle");
+    }
+    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,
+      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()],
+      // User plugins run first, then Shovel's core plugins
+      plugins: bundlesUserCodeInline ? [
+        ...userPlugins,
+        createConfigPlugin(projectRoot, outputDir, { platformDefaults }),
+        importMetaPlugin(),
+        assetsPlugin({
+          outDir: outputDir,
+          clientBuild: {
+            jsx: jsxOptions.jsx,
+            jsxFactory: jsxOptions.jsxFactory,
+            jsxFragment: jsxOptions.jsxFragment,
+            jsxImportSource: jsxOptions.jsxImportSource
+          }
+        })
+      ] : [createConfigPlugin(projectRoot, outputDir, { platformDefaults })],
+      // Config plugin needed for entry wrapper
+      metafile: true,
+      sourcemap,
+      minify,
+      treeShaking,
+      define: {
+        ...platformESBuildConfig.define ?? {},
+        // User-defined constants
+        ...shovelBuildConfig?.define ?? {},
+        // Inject output directory for runtime.outdir() resolution
+        __SHOVEL_OUTDIR__: JSON.stringify(outputDir),
+        // Inject git commit SHA for [git] placeholder
+        __SHOVEL_GIT__: JSON.stringify(getGitSHA(projectRoot))
+      },
+      // Path aliases from user config
+      alias: shovelBuildConfig?.alias,
+      external
+    };
+    if (bundlesUserCodeInline) {
+      applyJSXOptions(buildConfig, jsxOptions);
+    }
+    return buildConfig;
+  } catch (error) {
+    throw new Error(`Failed to create build configuration: ${error}`);
+  }
+}
+async function generatePackageJSON({
+  serverDir,
+  platform,
+  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"
+    );
+    logger.debug("Copied package.json", { serverDir });
+  } catch (error) {
+    logger.debug("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"
+      );
+      logger.debug("Generated package.json", { platform });
+    } catch (generateError) {
+      logger.debug("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",
+    platform,
+    workerCount: options.workers ? parseInt(options.workers, 10) : config.workers,
+    userBuildConfig: config.build
+  });
+  process.exit(0);
+}
+export {
+  buildCommand,
+  buildForProduction
+};

package/src/_chunks/chunk-ADR5RW57.js

@@ -0,0 +1,78 @@
+import {
+  generateConfigModule,
+  generateStorageTypes,
+  loadRawConfig
+} from "./chunk-GRAFMTEH.js";
+
+// src/plugins/shovel.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, isAbsolute } from "node:path";
+function createConfigPlugin(projectRoot, outDir = "dist", options = {}) {
+  const rawConfig = loadRawConfig(projectRoot);
+  const absoluteOutDir = isAbsolute(outDir) ? outDir : join(projectRoot, outDir);
+  const configModuleCode = generateConfigModule(rawConfig, {
+    projectDir: projectRoot,
+    outDir: absoluteOutDir,
+    platformDefaults: options.platformDefaults
+  });
+  const typesCode = generateStorageTypes(rawConfig, {
+    platformDefaults: options.platformDefaults
+  });
+  if (typesCode) {
+    const outputDir = isAbsolute(outDir) ? outDir : join(projectRoot, outDir);
+    const serverOutDir = join(outputDir, "server");
+    mkdirSync(serverOutDir, { recursive: true });
+    const typesPath = join(serverOutDir, "shovel.d.ts");
+    writeFileSync(typesPath, typesCode);
+  }
+  return {
+    name: "shovel-config",
+    setup(build) {
+      build.onResolve({ filter: /^shovel:config$/ }, (args) => ({
+        path: args.path,
+        namespace: "shovel-config"
+      }));
+      build.onLoad({ filter: /.*/, namespace: "shovel-config" }, () => ({
+        contents: configModuleCode,
+        loader: "js",
+        resolveDir: projectRoot
+      }));
+    }
+  };
+}
+function createEntryPlugin(projectRoot, entryCode) {
+  return {
+    name: "shovel-entry",
+    setup(build) {
+      build.onResolve({ filter: /^shovel:entry$/ }, (args) => ({
+        path: args.path,
+        namespace: "shovel-entry"
+      }));
+      build.onLoad({ filter: /.*/, namespace: "shovel-entry" }, () => ({
+        contents: entryCode,
+        loader: "js",
+        resolveDir: projectRoot
+      }));
+    }
+  };
+}
+
+// src/utils/git-sha.ts
+import { execSync } from "child_process";
+function getGitSHA(cwd) {
+  try {
+    return execSync("git rev-parse HEAD", {
+      encoding: "utf8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch (_err) {
+    return "";
+  }
+}
+
+export {
+  createConfigPlugin,
+  createEntryPlugin,
+  getGitSHA
+};