gencow 0.1.259 → 0.1.261

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

@@ -0,0 +1,224 @@
+import { createRequire } from "node:module";
+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
+// the ASTs with the user project's `typescript` (the CLI does not depend on it), so the
+// AST nodes are not statically typed here.
+
+const SCRIPT_FILE = /\.(?:[cm]?[jt]sx?)$/u;
+const TYPESCRIPT_FILE = /\.(?:[cm]?tsx?)$/u;
+const RELATIVE_SPECIFIER = /^\.{1,2}\//u;
+const DECLARATION_FILE = /\.d\.[cm]?ts$/u;
+
+export type MissingNamedImport = {
+  file: string;
+  line: number;
+  column: number;
+  name: string;
+  target: string;
+};
+
+type Context = {
+  ts: any;
+  compilerOptions: Record<string, unknown>;
+  // `null` marks a module whose export names cannot be known (or a cycle in progress).
+  exportCache: Map<string, Set<string> | null>;
+};
+
+// The project's typescript is the one the user compiles with. A missing or unusable copy
+// skips the check, so an unusual project is never blocked by the CLI.
+function loadProjectTypeScript(projectRoot: string): any | null {
+  try {
+    const requireFromProject = createRequire(join(projectRoot, "package.json"));
+    const ts = requireFromProject(requireFromProject.resolve("typescript"));
+    return typeof ts?.createSourceFile === "function" && typeof ts?.resolveModuleName === "function"
+      ? ts
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+// A `.d.ts` target is skipped: TypeScript prefers it over a sibling `.js` that esbuild
+// bundles, so a stale declaration file would report names the real module does export.
+function resolveRelativeModule(ctx: Context, fromFile: string, specifier: string): string | null {
+  if (!RELATIVE_SPECIFIER.test(specifier)) return null;
+  const resolved = ctx.ts.resolveModuleName(
+    specifier,
+    fromFile,
+    ctx.compilerOptions,
+    ctx.ts.sys,
+  ).resolvedModule;
+  if (!resolved || resolved.isExternalLibraryImport) return null;
+  if (DECLARATION_FILE.test(resolved.resolvedFileName)) return null;
+  return resolved.resolvedFileName;
+}
+
+// `null` when the file cannot be read, so the caller skips it instead of parsing empty text.
+function parseSource(ctx: Context, file: string): any | null {
+  const text = ctx.ts.sys.readFile(file);
+  if (typeof text !== "string") return null;
+  return ctx.ts.createSourceFile(file, text, ctx.ts.ScriptTarget.Latest, true);
+}
+
+function hasExportModifier(ts: any, statement: any): boolean {
+  return (statement.modifiers ?? []).some((modifier: any) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+
+function hasDefaultModifier(ts: any, statement: any): boolean {
+  return (statement.modifiers ?? []).some((modifier: any) => modifier.kind === ts.SyntaxKind.DefaultKeyword);
+}
+
+// Identifiers carry `text`; destructuring patterns carry `elements` (holes have no name).
+function bindingNames(binding: any, names: string[]): void {
+  if (!binding) return;
+  if (typeof binding.text === "string") {
+    names.push(binding.text);
+    return;
+  }
+  for (const element of binding.elements ?? []) bindingNames(element.name, names);
+}
+
+// Export names of a module, following `export *` chains. Types count as exports, so a
+// plain import of a type is accepted. Returns null when the names cannot be known.
+function exportNamesOf(ctx: Context, file: string): Set<string> | null {
+  if (ctx.exportCache.has(file)) return ctx.exportCache.get(file) ?? null;
+  ctx.exportCache.set(file, null);
+  const names = collectExportNames(ctx, file);
+  ctx.exportCache.set(file, names);
+  return names;
+}
+
+function collectExportNames(ctx: Context, file: string): Set<string> | null {
+  const { ts } = ctx;
+  if (!TYPESCRIPT_FILE.test(file)) return null;
+  const source = parseSource(ctx, file);
+  if (!source) return null;
+  const names = new Set<string>();
+  for (const statement of source.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      const clause = statement.exportClause;
+      if (!clause) {
+        // `export * from "pkg"` or an unresolved path leaves the names unknown.
+        const target = resolveRelativeModule(ctx, file, statement.moduleSpecifier.text);
+        const inner = target ? exportNamesOf(ctx, target) : null;
+        if (!inner) return null;
+        for (const name of inner) if (name !== "default") names.add(name);
+      } else if (ts.isNamespaceExport(clause)) {
+        names.add(clause.name.text);
+      } else {
+        for (const element of clause.elements) names.add(element.name.text);
+      }
+    } else if (ts.isExportAssignment(statement)) {
+      if (statement.isExportEquals) return null;
+      names.add("default");
+    } else if (hasExportModifier(ts, statement)) {
+      if (hasDefaultModifier(ts, statement)) {
+        names.add("default");
+      } else if (ts.isVariableStatement(statement)) {
+        const declared: string[] = [];
+        for (const declaration of statement.declarationList.declarations)
+          bindingNames(declaration.name, declared);
+        for (const name of declared) names.add(name);
+      } else if (statement.name?.text) {
+        names.add(statement.name.text);
+      }
+    }
+  }
+  return names;
+}
+
+function missingNamedImportsIn(ctx: Context, file: string): MissingNamedImport[] {
+  const { ts } = ctx;
+  const sourceFile = parseSource(ctx, file);
+  if (!sourceFile) return [];
+  const missing: MissingNamedImport[] = [];
+  for (const statement of sourceFile.statements) {
+    let specifiers: any[] = [];
+    let specifier: string | null = null;
+    if (ts.isImportDeclaration(statement)) {
+      const clause = statement.importClause;
+      const bindings = clause && !clause.isTypeOnly ? clause.namedBindings : undefined;
+      if (bindings && ts.isNamedImports(bindings)) {
+        specifiers = bindings.elements;
+        specifier = statement.moduleSpecifier.text;
+      }
+    } else if (
+      ts.isExportDeclaration(statement) &&
+      statement.moduleSpecifier &&
+      !statement.isTypeOnly &&
+      statement.exportClause &&
+      ts.isNamedExports(statement.exportClause)
+    ) {
+      specifiers = statement.exportClause.elements;
+      specifier = statement.moduleSpecifier.text;
+    }
+    if (!specifier) continue;
+    const target = resolveRelativeModule(ctx, file, specifier);
+    if (!target) continue;
+    const exported = exportNamesOf(ctx, target);
+    if (!exported) continue;
+    for (const element of specifiers) {
+      if (element.isTypeOnly) continue;
+      const nameNode = element.propertyName ?? element.name;
+      const name = nameNode.text;
+      if (exported.has(name)) continue;
+      const position = sourceFile.getLineAndCharacterOfPosition(nameNode.getStart(sourceFile));
+      // Column is 0-based like esbuild's, so both diagnostics in one output use the same convention.
+      missing.push({ file, line: position.line + 1, column: position.character, name, target });
+    }
+  }
+  return missing;
+}
+
+function isProjectSource(file: string, projectRoot: string): boolean {
+  return (
+    file.startsWith(`${projectRoot}${sep}`) &&
+    !file.split(sep).includes("node_modules") &&
+    SCRIPT_FILE.test(file)
+  );
+}
+
+// `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(
+  inputFiles: readonly string[],
+  projectRootInput: string,
+): MissingNamedImport[] {
+  const projectRoot = resolve(projectRootInput);
+  const ts = loadProjectTypeScript(projectRoot);
+  if (!ts) return [];
+  const ctx: Context = {
+    ts,
+    compilerOptions: {
+      moduleResolution: ts.ModuleResolutionKind?.Bundler ?? ts.ModuleResolutionKind?.NodeJs ?? 2,
+      module: ts.ModuleKind?.ESNext,
+      allowJs: true,
+      resolveJsonModule: true,
+    },
+    exportCache: new Map(),
+  };
+  try {
+    const missing: MissingNamedImport[] = [];
+    for (const file of inputFiles) {
+      if (isProjectSource(file, projectRoot)) missing.push(...missingNamedImportsIn(ctx, file));
+    }
+    return missing;
+  } catch {
+    return [];
+  }
+}
+
+// Formats each finding like an esbuild diagnostic, so the classifier reads it the same way.
+export function formatMissingNamedImports(
+  missing: readonly MissingNamedImport[],
+  projectRoot: string,
+): string[] {
+  return missing.map((item) => {
+    const target = relative(resolve(projectRoot), item.target).split(sep).join("/");
+    return `${item.file}:${item.line}:${item.column}: ERROR: No matching export in "${target}" for import "${item.name}"`;
+  });
+}

package/scripts/tooling-codegen-runtime.ts

@@ -10,6 +10,10 @@ import {
   createNodeProcessRunner,
   extractTables,
 } from "../../shared/src/codegen/index.ts";
+import {
+  findMissingNamedImports,
+  formatMissingNamedImports,
+} from "./codegen-named-import-check.ts";
 import {
   collectCrudCodegenMeta,
   collectProcedureRouteMaps,
@@ -109,9 +113,10 @@ async function transpileTypescriptForNodeDefault(
   await mkdir(workDir, { recursive: true });
   const tempDir = await mkdtemp(join(workDir, "codegen-extract-"));
   const outFile = join(tempDir, "index.mjs");
+  let inputFiles: string[] = [];
   try {
     const { build } = await loadEsbuildModule();
-    await build({
+    const result = (await build({
       entryPoints: [entryPath],
       outfile: outFile,
       bundle: true,
@@ -122,13 +127,16 @@ async function transpileTypescriptForNodeDefault(
       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));
   } catch (error) {
     const details = error instanceof Error ? error.message : String(error);
     throw new Error(
@@ -140,6 +148,22 @@ 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,
     cleanup: async () => {