@forwardimpact/librpc 0.1.102 → 0.1.104

package/bin/fit-unary.js

@@ -1,18 +1,24 @@
 #!/usr/bin/env node
 import "@forwardimpact/libpreflight/node22";
 
-import { readFileSync } from "node:fs";
 import { createCli } from "@forwardimpact/libcli";
 import { createClient, createTracer } from "@forwardimpact/librpc";
 import { createLogger } from "@forwardimpact/libtelemetry";
+import { createDefaultRuntime } from "@forwardimpact/libutil/runtime";
+
+const runtime = createDefaultRuntime();
 
 // `bun build --compile` injects FIT_UNARY_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_UNARY_VERSION ||
-  JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"))
-    .version;
+  runtime.proc.env.FIT_UNARY_VERSION ||
+  JSON.parse(
+    runtime.fsSync.readFileSync(
+      new URL("../package.json", import.meta.url),
+      "utf8",
+    ),
+  ).version;
 
 const definition = {
   name: "fit-unary",
@@ -27,7 +33,7 @@ const definition = {
   examples: ['fit-unary memory GetWindow \'{"resource_id":"..."}\''],
 };
 
-const cli = createCli(definition);
+const cli = createCli(definition, { runtime });
 const logger = createLogger("cli");
 
 /**
@@ -35,13 +41,13 @@ const logger = createLogger("cli");
  * @returns {Promise<void>}
  */
 async function main() {
-  const parsed = cli.parse(process.argv.slice(2));
-  if (!parsed) process.exit(0);
+  const parsed = cli.parse(runtime.proc.argv.slice(2));
+  if (!parsed) return runtime.proc.exit(0);
 
   const [service, method, requestJson] = parsed.positionals;
   if (!service || !method) {
     cli.usageError("expected arguments: <service> <method> [json-request]");
-    process.exit(2);
+    return runtime.proc.exit(2);
   }
 
   const request = requestJson ? JSON.parse(requestJson) : {};
@@ -49,11 +55,11 @@ async function main() {
   const client = await createClient(service, logger, tracer);
 
   const response = await client.callUnary(method, request);
-  console.log(JSON.stringify(response, null, 2));
+  runtime.proc.stdout.write(JSON.stringify(response, null, 2) + "\n");
 }
 
 main().catch((error) => {
   logger.exception("main", error);
   cli.error(error.message);
-  process.exit(1);
+  runtime.proc.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/librpc",
-  "version": "0.1.102",
+  "version": "0.1.104",
   "description": "gRPC server and client framework — ship service endpoints without reimplementing transport.",
   "keywords": [
     "grpc",

package/src/base.js

@@ -1,6 +1,7 @@
 import grpc from "@grpc/grpc-js";
 
 import { createObserver } from "@forwardimpact/libtelemetry";
+import { createDefaultProc } from "@forwardimpact/libutil/runtime";
 
 import { Interceptor, HmacAuth } from "./auth.js";
 import { definitions } from "./generated/definitions/exports.js";
@@ -23,12 +24,15 @@ export function createGrpc() {
 }
 
 /**
- * Default auth factory that creates authentication interceptor
+ * Default auth factory that creates authentication interceptor.
+ * Reads `SERVICE_SECRET` through `createDefaultProc().env` (a late-binding
+ * Proxy over `process.env`) rather than touching the `process` global
+ * directly — same read semantics as before, no ambient-dep smell.
  * @param {string} serviceName - Name of the service for the interceptor
  * @returns {Interceptor} Configured interceptor instance
  */
 export function createAuth(serviceName) {
-  const secret = process.env.SERVICE_SECRET;
+  const secret = createDefaultProc().env.SERVICE_SECRET;
   if (!secret) {
     throw new Error(
       `SERVICE_SECRET environment variable is required for service ${serviceName}`,

package/src/server.js

@@ -6,6 +6,7 @@ import {
   capitalizeFirstLetter,
 } from "./base.js";
 import { healthDefinition, createHealthHandlers } from "./health.js";
+import { createDefaultRuntime } from "@forwardimpact/libutil/runtime";
 
 /**
  * gRPC Server class using pre-compiled service definitions
@@ -14,6 +15,7 @@ import { healthDefinition, createHealthHandlers } from "./health.js";
 export class Server extends Rpc {
   #server;
   #service;
+  #runtime;
 
   /**
    * Creates a gRPC server for a service
@@ -24,6 +26,8 @@ export class Server extends Rpc {
    * @param {(serviceName: string, logger: object, tracer: object) => object} observerFn - Observer factory
    * @param {() => {grpc: object}} grpcFn - gRPC factory
    * @param {(serviceName: string) => object} authFn - Auth factory
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} [runtime] - Optional runtime bag;
+   *   falls back to `createDefaultRuntime()` so existing service callers keep working.
    */
   constructor(
     service,
@@ -33,11 +37,13 @@ export class Server extends Rpc {
     observerFn = createObserver,
     grpcFn = createGrpc,
     authFn = createAuth,
+    runtime = null,
   ) {
     if (!service) throw new Error("service is required");
 
     super(config, logger, tracer, observerFn, grpcFn, authFn);
     this.#service = service;
+    this.#runtime = runtime ?? createDefaultRuntime();
   }
 
   /** Starts the gRPC server */
@@ -170,10 +176,11 @@ export class Server extends Rpc {
         );
         callback(null, response);
       } catch (error) {
-        callback({
-          code: this.grpc().status.INTERNAL,
-          message: error?.message || String(error),
-        });
+        const code =
+          typeof error?.code === "number"
+            ? error.code
+            : this.grpc().status.INTERNAL;
+        callback({ code, message: error?.message || String(error) });
       }
     };
   }
@@ -203,6 +210,7 @@ export class Server extends Rpc {
 
   /** Sets up graceful shutdown handlers */
   #setupShutdown() {
+    const runtime = this.#runtime;
     const shutdown = async () => {
       this.observer().logger()?.info("Server", "Shutting down...");
 
@@ -211,7 +219,7 @@ export class Server extends Rpc {
         await this.#service.shutdown();
       }
 
-      this.#server.tryShutdown(() => process.exit(0));
+      this.#server.tryShutdown(() => runtime.proc.exit(0));
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);