@forwardimpact/libcodegen 0.1.59 → 0.1.61

package/bin/fit-codegen.js

@@ -2,8 +2,15 @@
 
 import "@forwardimpact/libpreflight/node22";
 
-import fs, { readFileSync } from "node:fs";
-import fsAsync from "node:fs/promises";
+// Bind protobufjs's `util.Long` before any other import evaluates. The
+// `@grpc/proto-loader` import below pulls in protobufjs's descriptor extension,
+// which calls `Root.fromJSON(...).resolveAll()` at module-evaluation time —
+// resolving a 64-bit field default needs `util.Long`, which `bun --compile`
+// leaves undefined (see long-init.js). This side-effect import must precede the
+// proto-loader import so the binding is in place before that resolveAll runs.
+import "../src/long-init.js";
+
+import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
 
@@ -11,7 +18,7 @@ import protoLoader from "@grpc/proto-loader";
 import mustache from "mustache";
 
 import { createCli, SummaryRenderer } from "@forwardimpact/libcli";
-import { Finder } from "@forwardimpact/libutil";
+import { createDefaultRuntime } from "@forwardimpact/libutil/runtime";
 import { Logger } from "@forwardimpact/libtelemetry";
 import {
   CodegenBase,
@@ -22,17 +29,8 @@ import {
 } from "@forwardimpact/libcodegen";
 import { createStorage } from "@forwardimpact/libstorage";
 
-// `bun build --compile` injects FIT_CODEGEN_VERSION via --define, eliminating
-// the readFileSync branch in the compiled binary (which would ENOENT against
-// the bunfs virtual mount). Source execution falls through to package.json.
-const VERSION =
-  process.env.FIT_CODEGEN_VERSION ||
-  JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"))
-    .version;
-
 const definition = {
   name: "fit-codegen",
-  version: VERSION,
   description:
     "Generate protobuf types, service clients, and definitions from .proto files in installed @forwardimpact/* packages (node_modules/@forwardimpact/*/proto/) and an optional project-local proto/ directory.",
   globalOptions: {
@@ -62,7 +60,11 @@ const definition = {
   ],
 };
 
-const cli = createCli(definition);
+const runtime = createDefaultRuntime();
+const cli = createCli(definition, {
+  runtime,
+  packageJsonUrl: new URL("../package.json", import.meta.url),
+});
 
 /**
  * Create tar.gz bundle of all directories inside sourcePath
@@ -110,6 +112,7 @@ function parseFlags() {
   const { values } = parsed;
   const doAll = values.all;
   return {
+    doAll,
     doTypes: doAll || values.type,
     doServices: doAll || values.service,
     doClients: doAll || values.client,
@@ -178,6 +181,7 @@ function createCodegen(
   mustache,
   protoLoader,
   fs,
+  runtime,
 ) {
   const base = new CodegenBase(
     protoDirs,
@@ -186,6 +190,7 @@ function createCodegen(
     mustache,
     protoLoader,
     fs,
+    runtime,
   );
   return {
     types: new CodegenTypes(base),
@@ -327,6 +332,17 @@ async function runCodegen(protoDirs, projectRoot, finder) {
 
   await generatedStorage.ensureBucket();
 
+  // Full regeneration (--all) clears the content directories first so that a
+  // renamed or removed proto leaves no orphaned per-proto artifacts. The
+  // services exports step scans the services/ directory, so a stale service
+  // dir would otherwise be re-exported and import types that no longer exist.
+  // Partial flags intentionally preserve sibling artifacts and are not cleaned.
+  if (parsedFlags.doAll) {
+    for (const dir of ["types", "services", "definitions", "proto"]) {
+      fs.rmSync(path.join(sourcePath, dir), { recursive: true, force: true });
+    }
+  }
+
   // Write package.json with "type": "module" so Node.js treats generated
   // ES module files correctly and avoids MODULE_TYPELESS_PACKAGE_JSON warnings.
   const generatedPkgPath = path.join(sourcePath, "package.json");
@@ -344,6 +360,7 @@ async function runCodegen(protoDirs, projectRoot, finder) {
     mustache,
     protoLoader,
     fs,
+    runtime,
   );
   await executeGeneration(codegens, sourcePath, parsedFlags);
 
@@ -358,8 +375,11 @@ async function runCodegen(protoDirs, projectRoot, finder) {
  */
 async function main() {
   try {
-    const logger = new Logger("codegen");
-    const finder = new Finder(fsAsync, logger, process);
+    const logger = new Logger("codegen", runtime);
+    // The shared runtime.finder carries a no-op logger; bind this CLI's logger
+    // so createPackageSymlinks (the one logging Finder consumer) keeps emitting
+    // symlink debug logs.
+    const finder = runtime.finder.withLogger(logger);
     const projectRoot = finder.findProjectRoot(process.cwd());
 
     const protoDirs = discoverProtoDirs(projectRoot);
@@ -373,7 +393,7 @@ async function main() {
 
     await runCodegen(protoDirs, projectRoot, finder);
   } catch (err) {
-    const logger = new Logger("codegen");
+    const logger = new Logger("codegen", runtime);
     logger.exception("main", err);
     cli.error(err.message);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libcodegen",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "description": "Protobuf code generation — keep types in sync with proto definitions without hand-writing.",
   "keywords": [
     "codegen",

package/src/base.js

@@ -1,6 +1,6 @@
-import { execFile } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import protobuf from "protobufjs";
+import "./long-init.js";
 
 /** Convert camelCase to snake_case (protobufjs normalizes field names) */
 function camelToSnake(str) {
@@ -61,6 +61,7 @@ export class CodegenBase {
   #mustache;
   #protoLoader;
   #fs;
+  #subprocess;
 
   /**
    * Creates a new codegen base instance with dependency injection
@@ -70,8 +71,17 @@ export class CodegenBase {
    * @param {object} mustache - Mustache template rendering module
    * @param {object} protoLoader - Protocol buffer loader module
    * @param {object} fs - File system module (sync operations only)
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag
    */
-  constructor(protoDirs, projectRoot, path, mustache, protoLoader, fs) {
+  constructor(
+    protoDirs,
+    projectRoot,
+    path,
+    mustache,
+    protoLoader,
+    fs,
+    runtime,
+  ) {
     if (!protoDirs || !Array.isArray(protoDirs) || protoDirs.length === 0) {
       throw new Error("protoDirs must be a non-empty array");
     }
@@ -80,6 +90,7 @@ export class CodegenBase {
     if (!mustache) throw new Error("mustache module is required");
     if (!protoLoader) throw new Error("protoLoader module is required");
     if (!fs) throw new Error("fs module is required");
+    if (!runtime) throw new Error("runtime is required");
 
     this.#protoDirs = protoDirs;
     this.#projectRoot = projectRoot;
@@ -87,6 +98,7 @@ export class CodegenBase {
     this.#mustache = mustache;
     this.#protoLoader = protoLoader;
     this.#fs = fs;
+    this.#subprocess = runtime.subprocess;
   }
 
   /**
@@ -149,7 +161,7 @@ export class CodegenBase {
 
   /**
    * Load mustache template for given kind
-   * @param {"service"|"client"|"exports"|"definition"|"definitions-exports"|"services-exports"} kind - Template kind
+   * @param {"service"|"client"|"definition"|"definitions-exports"|"services-exports"} kind - Template kind
    * @returns {string} Template content
    */
   loadTemplate(kind) {
@@ -182,22 +194,28 @@ export class CodegenBase {
    * Run a command with arguments and options
    * @param {string} cmd - Command to execute
    * @param {string[]} args - Command-line arguments
-   * @param {object} [opts] - Child process options
+   * @param {object} [opts] - Subprocess options (e.g. cwd)
    * @returns {Promise<void>} Resolves when the command completes successfully
    */
-  run(cmd, args, opts = {}) {
-    return new Promise((resolvePromise, reject) => {
-      const child = execFile(
-        cmd,
-        args,
-        { stdio: "inherit", ...opts },
-        (err) => {
-          if (err) reject(err);
-          else resolvePromise();
-        },
-      );
-      child.on("error", reject);
+  async run(cmd, args, opts = {}) {
+    // `stdio: "inherit"` forwards to the underlying execFile/spawn so the
+    // child's stdout/stderr go straight to the parent's fds — preserving the
+    // exact pre-1370 behavior (origin/main also ran execFile with
+    // stdio:"inherit"), so `just codegen` shows protoc/pbjs progress live.
+    // With inherited stdio the buffered result is empty, so the error path
+    // below falls back to the exit code. Capture-mode callers override via
+    // `opts.stdio`.
+    const result = await this.#subprocess.run(cmd, args, {
+      stdio: "inherit",
+      ...opts,
     });
+    if (result.exitCode !== 0) {
+      const msg =
+        result.stderr?.trim() ||
+        result.stdout?.trim() ||
+        `exited with code ${result.exitCode}`;
+      throw new Error(`Command failed: ${cmd} ${args.join(" ")}\n${msg}`);
+    }
   }
 
   /**

package/src/long-init.js

@@ -0,0 +1,17 @@
+// protobufjs populates `util.Long` through a dynamic `inquire("long")` that
+// `bun build --compile` cannot resolve, leaving it undefined when a 64-bit
+// field default is computed — crashing the compiled fit-codegen binary at
+// startup (`util.Long.fromNumber is not a function`). Bind it explicitly.
+//
+// Imported for its side effect both by `bin/fit-codegen.js` (ahead of the
+// `@grpc/proto-loader` import, whose descriptor extension runs `resolveAll()`
+// at module-evaluation time) and by base.js (ahead of its own runtime
+// `Root.resolveAll()`). ES module imports evaluate in source order, so an
+// ordered side-effect import binds before the proto-loading code runs —
+// inline binding statements in an entry body would not, since imports hoist
+// above them.
+import protobuf from "protobufjs";
+import Long from "long";
+
+protobuf.util.Long = Long;
+protobuf.configure();

package/templates/client.js.mustache

@@ -13,12 +13,13 @@ export class {{className}} extends Client {
   /**
    * Creates a new {{serviceName}} client instance
    * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
    * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
    * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
    * @param {Function} [authFn] - Optional authentication function
    */
-  constructor(config, logger = null, tracer = null, authFn = createAuth) {
-    super(config, logger, tracer, createObserver, createGrpc, authFn);
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
   }
 
 {{#methods}}