gencow 0.1.261 → 0.1.263

package/runtime/tooling.mjs

@@ -6905,6 +6905,9 @@ function missingNamedImportsIn(ctx, file2) {
 function isProjectSource(file2, projectRoot) {
   return file2.startsWith(`${projectRoot}${sep2}`) && !file2.split(sep2).includes("node_modules") && SCRIPT_FILE.test(file2);
 }
+function hasProjectTypeScript(projectRootInput) {
+  return loadProjectTypeScript(resolve10(projectRootInput)) !== null;
+}
 function findMissingNamedImports(inputFiles, projectRootInput) {
   const projectRoot = resolve10(projectRootInput);
   const ts = loadProjectTypeScript(projectRoot);
@@ -7014,34 +7017,39 @@ async function loadEsbuildModule() {
   }
   return { build: mod.build };
 }
+function esbuildEntryOptions(entryPath) {
+  return {
+    entryPoints: [entryPath],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    sourcemap: false,
+    logLevel: "silent",
+    packages: "external",
+    external: [...nodeBuiltinExternals, "bun", "bun:*"],
+    metafile: true,
+    banner: {
+      js: [
+        'import { createRequire as __gencowCreateRequire } from "node:module";',
+        "const require = __gencowCreateRequire(import.meta.url);"
+      ].join("\n")
+    }
+  };
+}
+function bundledInputFiles(result) {
+  const inputs = result?.metafile?.inputs;
+  return Object.keys(inputs ?? {}).map((file2) => resolve11(file2));
+}
 async function transpileTypescriptForNodeDefault(entryPath, context) {
   const workDir = join7(resolve11(context.projectRoot), ".gencow");
   await mkdir(workDir, { recursive: true });
   const tempDir = await mkdtemp(join7(workDir, "codegen-extract-"));
   const outFile = join7(tempDir, "index.mjs");
-  let inputFiles = [];
+  let inputFiles;
   try {
     const { build } = await loadEsbuildModule();
-    const result = await build({
-      entryPoints: [entryPath],
-      outfile: outFile,
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      target: "node20",
-      sourcemap: false,
-      logLevel: "silent",
-      packages: "external",
-      external: [...nodeBuiltinExternals, "bun", "bun:*"],
-      metafile: true,
-      banner: {
-        js: [
-          'import { createRequire as __gencowCreateRequire } from "node:module";',
-          "const require = __gencowCreateRequire(import.meta.url);"
-        ].join("\n")
-      }
-    });
-    inputFiles = Object.keys(result?.metafile?.inputs ?? {}).map((file2) => resolve11(file2));
+    inputFiles = bundledInputFiles(await build({ ...esbuildEntryOptions(entryPath), outfile: outFile }));
   } catch (error62) {
     const details = error62 instanceof Error ? error62.message : String(error62);
     throw new Error(
@@ -7053,27 +7061,55 @@ async function transpileTypescriptForNodeDefault(entryPath, context) {
       ].join("\n")
     );
   }
-  const missingImports = formatMissingNamedImports(
-    findMissingNamedImports(inputFiles, context.projectRoot),
-    context.projectRoot
-  );
-  if (missingImports.length > 0) {
-    throw new Error(
-      [
-        "Failed to transpile TypeScript entry for codegen extraction.",
-        `Resolved entry: ${entryPath}`,
-        `Transpile error: Build failed with ${missingImports.length} error${missingImports.length === 1 ? "" : "s"}:`,
-        ...missingImports
-      ].join("\n")
-    );
-  }
   return {
     modulePath: outFile,
+    inputFiles,
     cleanup: async () => {
       await rm(tempDir, { recursive: true, force: true });
     }
   };
 }
+var MISSING_EXPORT_DIAGNOSTIC = /No matching export in "/u;
+var NAMED_IMPORT_CHECK_SKIPPED_MESSAGE = "Warning: codegen skipped the named-import check because this project has no typescript package. Install typescript in the project (for example: npm install -D typescript) and rerun codegen.";
+function defaultWarn(message) {
+  process.stderr.write(`${message}
+`);
+}
+function namedImportLoadFailure(appEntryAbs, runtime, transpileErrorLines) {
+  return new Error(
+    [
+      "Failed to load app module for codegen extraction.",
+      `Resolved entry: ${appEntryAbs}`,
+      `Runtime: ${runtime}`,
+      "Expected export: default defineApi({ procedures: { ... } }) or module object with procedures.",
+      ...transpileErrorLines
+    ].join("\n")
+  );
+}
+async function assertNamedImportsResolve(input2) {
+  if (!hasProjectTypeScript(input2.projectRoot)) {
+    input2.warn(NAMED_IMPORT_CHECK_SKIPPED_MESSAGE);
+    return;
+  }
+  let inputFiles = input2.inputFiles;
+  if (!inputFiles) {
+    try {
+      const { build } = await loadEsbuildModule();
+      inputFiles = bundledInputFiles(await build({ ...esbuildEntryOptions(input2.appEntryAbs), write: false }));
+    } catch (error62) {
+      const details = error62 instanceof Error ? error62.message : String(error62);
+      if (input2.runtime === "bun" && !MISSING_EXPORT_DIAGNOSTIC.test(details)) return;
+      throw namedImportLoadFailure(input2.appEntryAbs, input2.runtime, [`Transpile error: ${details}`]);
+    }
+  }
+  const missing = findMissingNamedImports(inputFiles, input2.projectRoot);
+  if (missing.length > 0) {
+    throw namedImportLoadFailure(input2.appEntryAbs, input2.runtime, [
+      `Transpile error: Build failed with ${missing.length} error${missing.length === 1 ? "" : "s"}:`,
+      ...formatMissingNamedImports(missing, input2.projectRoot)
+    ]);
+  }
+}
 function createCliRegistryExtractorDeps(options = {}) {
   let collectors = null;
   return {
@@ -7085,23 +7121,39 @@ function createCliRegistryExtractorDeps(options = {}) {
       const legacyBeforeImport = coreModule.captureLegacyRealtimeChannels?.() ?? [];
       let moduleImportPath = appEntryAbs;
       let cleanup;
-      if (runtime !== "bun" && appEntryAbs.endsWith(".ts")) {
+      if (appEntryAbs.endsWith(".ts")) {
+        let inputFiles;
+        if (runtime !== "bun") {
+          try {
+            const transpile = options.transpileTypescriptForNode ?? transpileTypescriptForNodeDefault;
+            const transpiled = await transpile(appEntryAbs, { projectRoot: input2.projectRoot });
+            moduleImportPath = transpiled.modulePath;
+            cleanup = transpiled.cleanup;
+            inputFiles = transpiled.inputFiles;
+          } catch (error62) {
+            const details = error62 instanceof Error ? error62.message : String(error62);
+            throw new Error(
+              [
+                "Failed to load app module for codegen extraction.",
+                `Resolved entry: ${appEntryAbs}`,
+                `Runtime: ${runtime}`,
+                "Node runtime requires a TypeScript loader adapter for in-process extraction.",
+                `Transpile error: ${details}`
+              ].join("\n")
+            );
+          }
+        }
         try {
-          const transpile = options.transpileTypescriptForNode ?? transpileTypescriptForNodeDefault;
-          const transpiled = await transpile(appEntryAbs, { projectRoot: input2.projectRoot });
-          moduleImportPath = transpiled.modulePath;
-          cleanup = transpiled.cleanup;
+          await assertNamedImportsResolve({
+            appEntryAbs,
+            runtime,
+            projectRoot: input2.projectRoot,
+            inputFiles,
+            warn: options.warn ?? defaultWarn
+          });
         } catch (error62) {
-          const details = error62 instanceof Error ? error62.message : String(error62);
-          throw new Error(
-            [
-              "Failed to load app module for codegen extraction.",
-              `Resolved entry: ${appEntryAbs}`,
-              `Runtime: ${runtime}`,
-              "Node runtime requires a TypeScript loader adapter for in-process extraction.",
-              `Transpile error: ${details}`
-            ].join("\n")
-          );
+          await cleanup?.();
+          throw error62;
         }
       }
       let appModule;

package/scripts/codegen-named-import-check.ts

@@ -3,8 +3,9 @@ import { join, relative, resolve, sep } from "node:path";
 
 // esbuild drops an unused import of a missing name without a diagnostic, and it only
 // warns for namespace member access. Codegen would then load a backend that names an
-// export its module does not have. This check runs after a successful build, over the
-// project's own sources, and only for relative named imports and re-exports. It reads
+// export its module does not have. This check runs after esbuild bundles the entry and before
+// the module is imported, on every runtime, over the project's own sources, and only for relative
+// named imports and re-exports. It reads
 // the ASTs with the user project's `typescript` (the CLI does not depend on it), so the
 // AST nodes are not statically typed here.
 
@@ -182,6 +183,11 @@ function isProjectSource(file: string, projectRoot: string): boolean {
   );
 }
 
+// Whether the check can run for this project. Callers warn when it cannot, so a skipped check is visible.
+export function hasProjectTypeScript(projectRootInput: string): boolean {
+  return loadProjectTypeScript(resolve(projectRootInput)) !== null;
+}
+
 // `inputFiles` are the files esbuild bundled (absolute paths). Returns every relative named
 // import whose target module does not export the name. Any internal failure skips the check.
 export function findMissingNamedImports(

package/scripts/tooling-codegen-runtime.ts

@@ -13,6 +13,7 @@ import {
 import {
   findMissingNamedImports,
   formatMissingNamedImports,
+  hasProjectTypeScript,
 } from "./codegen-named-import-check.ts";
 import {
   collectCrudCodegenMeta,
@@ -44,7 +45,13 @@ type CliRegistryRuntimeOptions = {
   transpileTypescriptForNode?: (
     entryPath: string,
     context: { projectRoot: string },
-  ) => Promise<{ modulePath: string; cleanup?: (() => Promise<void>) | (() => void) }>;
+  ) => Promise<{
+    modulePath: string;
+    inputFiles?: string[];
+    cleanup?: (() => Promise<void>) | (() => void);
+  }>;
+  // Receives the one-line notice when the named-import check is skipped. Defaults to stderr.
+  warn?: (message: string) => void;
   coreModule?: CoreModuleShape;
   collectors?: Pick<RegistryRuntimeCollectors, "collectCrudCodegenMeta" | "collectProcedureRouteMaps">;
 };
@@ -105,38 +112,46 @@ async function loadEsbuildModule(): Promise<{ build(options: Record<string, unkn
   return { build: mod.build };
 }
 
+// Bundle options shared by the node transpile and the import check, so both see the same module graph.
+function esbuildEntryOptions(entryPath: string): Record<string, unknown> {
+  return {
+    entryPoints: [entryPath],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    sourcemap: false,
+    logLevel: "silent",
+    packages: "external",
+    external: [...nodeBuiltinExternals, "bun", "bun:*"],
+    metafile: true,
+    banner: {
+      js: [
+        'import { createRequire as __gencowCreateRequire } from "node:module";',
+        "const require = __gencowCreateRequire(import.meta.url);",
+      ].join("\n"),
+    },
+  };
+}
+
+// esbuild reports inputs relative to the process working directory (its default).
+function bundledInputFiles(result: unknown): string[] {
+  const inputs = (result as { metafile?: { inputs?: Record<string, unknown> } } | undefined)?.metafile?.inputs;
+  return Object.keys(inputs ?? {}).map((file) => resolve(file));
+}
+
 async function transpileTypescriptForNodeDefault(
   entryPath: string,
   context: { projectRoot: string },
-): Promise<{ modulePath: string; cleanup?: () => Promise<void> }> {
+): Promise<{ modulePath: string; inputFiles: string[]; cleanup?: () => Promise<void> }> {
   const workDir = join(resolve(context.projectRoot), ".gencow");
   await mkdir(workDir, { recursive: true });
   const tempDir = await mkdtemp(join(workDir, "codegen-extract-"));
   const outFile = join(tempDir, "index.mjs");
-  let inputFiles: string[] = [];
+  let inputFiles: string[];
   try {
     const { build } = await loadEsbuildModule();
-    const result = (await build({
-      entryPoints: [entryPath],
-      outfile: outFile,
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      target: "node20",
-      sourcemap: false,
-      logLevel: "silent",
-      packages: "external",
-      external: [...nodeBuiltinExternals, "bun", "bun:*"],
-      metafile: true,
-      banner: {
-        js: [
-          'import { createRequire as __gencowCreateRequire } from "node:module";',
-          "const require = __gencowCreateRequire(import.meta.url);",
-        ].join("\n"),
-      },
-    })) as { metafile?: { inputs?: Record<string, unknown> } } | undefined;
-    // esbuild reports inputs relative to the process working directory (its default).
-    inputFiles = Object.keys(result?.metafile?.inputs ?? {}).map((file) => resolve(file));
+    inputFiles = bundledInputFiles(await build({ ...esbuildEntryOptions(entryPath), outfile: outFile }));
   } catch (error) {
     const details = error instanceof Error ? error.message : String(error);
     throw new Error(
@@ -148,30 +163,76 @@ async function transpileTypescriptForNodeDefault(
       ].join("\n"),
     );
   }
-  // esbuild accepts an unused or type-position import of a missing name; reject it here
-  // before codegen loads the module, in the same diagnostic shape as an esbuild error.
-  const missingImports = formatMissingNamedImports(
-    findMissingNamedImports(inputFiles, context.projectRoot),
-    context.projectRoot,
-  );
-  if (missingImports.length > 0) {
-    throw new Error(
-      [
-        "Failed to transpile TypeScript entry for codegen extraction.",
-        `Resolved entry: ${entryPath}`,
-        `Transpile error: Build failed with ${missingImports.length} error${missingImports.length === 1 ? "" : "s"}:`,
-        ...missingImports,
-      ].join("\n"),
-    );
-  }
   return {
     modulePath: outFile,
+    inputFiles,
     cleanup: async () => {
       await rm(tempDir, { recursive: true, force: true });
     },
   };
 }
 
+const MISSING_EXPORT_DIAGNOSTIC = /No matching export in "/u;
+
+const NAMED_IMPORT_CHECK_SKIPPED_MESSAGE =
+  "Warning: codegen skipped the named-import check because this project has no typescript package. " +
+  "Install typescript in the project (for example: npm install -D typescript) and rerun codegen.";
+
+function defaultWarn(message: string): void {
+  process.stderr.write(`${message}\n`);
+}
+
+function namedImportLoadFailure(appEntryAbs: string, runtime: string, transpileErrorLines: string[]): Error {
+  return new Error(
+    [
+      "Failed to load app module for codegen extraction.",
+      `Resolved entry: ${appEntryAbs}`,
+      `Runtime: ${runtime}`,
+      "Expected export: default defineApi({ procedures: { ... } }) or module object with procedures.",
+      ...transpileErrorLines,
+    ].join("\n"),
+  );
+}
+
+// Runs before the app module is imported, on every runtime. esbuild accepts an unused or
+// type-position import of a missing name, and Bun rejects a used one without a location, so this
+// check decides first. The bundle inputs come from the node transpile when it ran, otherwise from
+// an in-memory esbuild bundle with the same options.
+async function assertNamedImportsResolve(input: {
+  appEntryAbs: string;
+  runtime: string;
+  projectRoot: string;
+  inputFiles?: string[];
+  warn: (message: string) => void;
+}): Promise<void> {
+  if (!hasProjectTypeScript(input.projectRoot)) {
+    input.warn(NAMED_IMPORT_CHECK_SKIPPED_MESSAGE);
+    return;
+  }
+  let inputFiles = input.inputFiles;
+  if (!inputFiles) {
+    try {
+      const { build } = await loadEsbuildModule();
+      inputFiles = bundledInputFiles(await build({ ...esbuildEntryOptions(input.appEntryAbs), write: false }));
+    } catch (error) {
+      const details = error instanceof Error ? error.message : String(error);
+      // Bun can run inputs esbuild rejects (for example `with { type: "text" }`). On bun those failures
+      // skip the check and bun's loader reports any real error. A missing import in such a backend is
+      // not caught here. A missing-export diagnostic is still reported, since it is this check's domain.
+      // On node the transpile already failed above, so this branch is bun-only in practice.
+      if (input.runtime === "bun" && !MISSING_EXPORT_DIAGNOSTIC.test(details)) return;
+      throw namedImportLoadFailure(input.appEntryAbs, input.runtime, [`Transpile error: ${details}`]);
+    }
+  }
+  const missing = findMissingNamedImports(inputFiles, input.projectRoot);
+  if (missing.length > 0) {
+    throw namedImportLoadFailure(input.appEntryAbs, input.runtime, [
+      `Transpile error: Build failed with ${missing.length} error${missing.length === 1 ? "" : "s"}:`,
+      ...formatMissingNamedImports(missing, input.projectRoot),
+    ]);
+  }
+}
+
 function createCliRegistryExtractorDeps(options: CliRegistryRuntimeOptions = {}): RegistryExtractorDeps {
   let collectors: RegistryRuntimeCollectors | null = null;
   return {
@@ -184,23 +245,39 @@ function createCliRegistryExtractorDeps(options: CliRegistryRuntimeOptions = {})
       let moduleImportPath = appEntryAbs;
       let cleanup: (() => Promise<void>) | (() => void) | undefined;
 
-      if (runtime !== "bun" && appEntryAbs.endsWith(".ts")) {
+      if (appEntryAbs.endsWith(".ts")) {
+        let inputFiles: string[] | undefined;
+        if (runtime !== "bun") {
+          try {
+            const transpile = options.transpileTypescriptForNode ?? transpileTypescriptForNodeDefault;
+            const transpiled = await transpile(appEntryAbs, { projectRoot: input.projectRoot });
+            moduleImportPath = transpiled.modulePath;
+            cleanup = transpiled.cleanup;
+            inputFiles = transpiled.inputFiles;
+          } catch (error) {
+            const details = error instanceof Error ? error.message : String(error);
+            throw new Error(
+              [
+                "Failed to load app module for codegen extraction.",
+                `Resolved entry: ${appEntryAbs}`,
+                `Runtime: ${runtime}`,
+                "Node runtime requires a TypeScript loader adapter for in-process extraction.",
+                `Transpile error: ${details}`,
+              ].join("\n"),
+            );
+          }
+        }
         try {
-          const transpile = options.transpileTypescriptForNode ?? transpileTypescriptForNodeDefault;
-          const transpiled = await transpile(appEntryAbs, { projectRoot: input.projectRoot });
-          moduleImportPath = transpiled.modulePath;
-          cleanup = transpiled.cleanup;
+          await assertNamedImportsResolve({
+            appEntryAbs,
+            runtime,
+            projectRoot: input.projectRoot,
+            inputFiles,
+            warn: options.warn ?? defaultWarn,
+          });
         } catch (error) {
-          const details = error instanceof Error ? error.message : String(error);
-          throw new Error(
-            [
-              "Failed to load app module for codegen extraction.",
-              `Resolved entry: ${appEntryAbs}`,
-              `Runtime: ${runtime}`,
-              "Node runtime requires a TypeScript loader adapter for in-process extraction.",
-              `Transpile error: ${details}`,
-            ].join("\n"),
-          );
+          await cleanup?.();
+          throw error;
         }
       }