@forwardimpact/librpc 0.1.104 → 0.1.106

package/bin/fit-unary.js

@@ -8,21 +8,8 @@ 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 =
-  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",
-  version: VERSION,
   description: "Make a unary gRPC call to a service",
   usage: "fit-unary <service> <method> [json-request]",
   globalOptions: {
@@ -33,8 +20,11 @@ const definition = {
   examples: ['fit-unary memory GetWindow \'{"resource_id":"..."}\''],
 };
 
-const cli = createCli(definition, { runtime });
-const logger = createLogger("cli");
+const cli = createCli(definition, {
+  runtime,
+  packageJsonUrl: new URL("../package.json", import.meta.url),
+});
+const logger = createLogger("cli", runtime);
 
 /**
  * Makes a unary gRPC call to a service

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/librpc",
-  "version": "0.1.104",
+  "version": "0.1.106",
   "description": "gRPC server and client framework — ship service endpoints without reimplementing transport.",
   "keywords": [
     "grpc",
@@ -20,9 +20,9 @@
   "jobs": [
     {
       "user": "Platform Builders",
-      "goal": "Keep Service Contracts Typed",
+      "goal": "Ship Service Endpoints Without Boilerplate",
       "trigger": "Starting a new service and reaching for last project's copy-pasted transport boilerplate.",
-      "bigHire": "ship a service endpoint without reimplementing transport.",
+      "bigHire": "ship a gRPC service endpoint without reimplementing transport.",
       "littleHire": "call a service without managing connections or retries.",
       "competesWith": "copy-pasting boilerplate; hand-writing protobuf clients; tolerating the duplication"
     }

package/src/base.js

@@ -1,7 +1,6 @@
 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";
@@ -24,15 +23,22 @@ export function createGrpc() {
 }
 
 /**
- * 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.
+ * Default auth factory that creates an authentication interceptor. Reads
+ * `SERVICE_SECRET` from the injected `runtime.proc.env` rather than
+ * constructing its own process collaborator — the runtime is threaded from the
+ * entry point through `Server`/`Client` (no leaf-collaborator construction in
+ * src, Success Criterion 9).
  * @param {string} serviceName - Name of the service for the interceptor
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag
  * @returns {Interceptor} Configured interceptor instance
  */
-export function createAuth(serviceName) {
-  const secret = createDefaultProc().env.SERVICE_SECRET;
+export function createAuth(serviceName, runtime) {
+  if (!runtime?.proc) {
+    throw new Error(
+      `createAuth requires an injected runtime for service ${serviceName}`,
+    );
+  }
+  const secret = runtime.proc.env.SERVICE_SECRET;
   if (!secret) {
     throw new Error(
       `SERVICE_SECRET environment variable is required for service ${serviceName}`,
@@ -54,14 +60,16 @@ export class Rpc {
   /**
    * Creates a new Rpc instance
    * @param {object} config - Configuration object
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required), threaded to `authFn`
    * @param {object} [logger] - Optional logger instance
    * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
    * @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 {(serviceName: string, runtime: object) => object} authFn - Auth factory
    */
   constructor(
     config,
+    runtime,
     logger = null,
     tracer = null,
     observerFn = createObserver,
@@ -69,6 +77,7 @@ export class Rpc {
     authFn = createAuth,
   ) {
     if (!config) throw new Error("config is required");
+    if (!runtime) throw new Error("runtime is required");
     if (typeof observerFn !== "function")
       throw new Error("observerFn must be a function");
     if (typeof grpcFn !== "function")
@@ -82,8 +91,9 @@ export class Rpc {
     const { grpc } = grpcFn();
     this.#grpc = grpc;
 
-    // Setup authentication
-    this.#auth = authFn(this.config.name);
+    // Setup authentication (the default factory reads SERVICE_SECRET off the
+    // injected runtime; a mock authFn ignores it)
+    this.#auth = authFn(this.config.name, runtime);
 
     // Create observer with logger and tracer
     this.#observer = observerFn(this.config.name, logger, tracer);

package/src/client.js

@@ -19,15 +19,17 @@ export class Client extends Rpc {
   /**
    * Creates a new Client instance
    * @param {object} config - Configuration object
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required), threaded to `authFn`
    * @param {object} [logger] - Optional logger instance
    * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
    * @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 {(serviceName: string, runtime: object) => object} authFn - Auth factory
    * @param {import("@forwardimpact/libutil").Retry} [retry] - Optional retry instance for handling transient errors
    */
   constructor(
     config,
+    runtime,
     logger = null,
     tracer = null,
     observerFn = createObserver,
@@ -35,7 +37,7 @@ export class Client extends Rpc {
     authFn = createAuth,
     retry = null,
   ) {
-    super(config, logger, tracer, observerFn, grpcFn, authFn);
+    super(config, runtime, logger, tracer, observerFn, grpcFn, authFn);
     this.#retry = retry || createRetry({ retries: 10, delay: 1000 });
     this.#setupClient();
   }

package/src/index.js

@@ -2,6 +2,7 @@ import grpc from "@grpc/grpc-js";
 
 import { createServiceConfig } from "@forwardimpact/libconfig";
 import { Tracer } from "@forwardimpact/libtelemetry/tracer.js";
+import { createDefaultRuntime } from "@forwardimpact/libutil/runtime";
 
 import { capitalizeFirstLetter } from "./base.js";
 import * as exports from "./generated/services/exports.js";
@@ -30,11 +31,17 @@ export const clients = exports.clients || {};
 export async function createTracer(serviceName) {
   const traceConfig = await createServiceConfig("trace");
   const { TraceClient } = clients;
-  const traceClient = new TraceClient(traceConfig);
+  // createTracer is a composition-root factory; it builds the production
+  // runtime as its DI root, threads it into the TraceClient (so the client's
+  // auth reads SERVICE_SECRET off the bag) and into the Tracer (and thus every
+  // Span) via its clock.
+  const runtime = createDefaultRuntime();
+  const traceClient = new TraceClient(traceConfig, runtime);
   return new Tracer({
     serviceName,
     traceClient,
     grpcMetadata: grpc.Metadata,
+    clock: runtime.clock,
   });
 }
 
@@ -60,6 +67,10 @@ export async function createClient(name, logger = null, tracer = null) {
   // Create config for the service
   const config = await createServiceConfig(name);
 
-  // Create and return the client instance with logger and tracer
-  return new ClientClass(config, logger, tracer);
+  // createClient is a composition-root factory; build the production runtime
+  // here and thread it so the client's auth reads SERVICE_SECRET off the bag.
+  const runtime = createDefaultRuntime();
+
+  // Create and return the client instance (runtime is the required 2nd arg)
+  return new ClientClass(config, runtime, logger, tracer);
 }

package/src/server.js

@@ -6,7 +6,6 @@ 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
@@ -21,29 +20,29 @@ export class Server extends Rpc {
    * Creates a gRPC server for a service
    * @param {object} service - Service instance with business logic
    * @param {object} config - Server configuration
-   * @param {object} [logger] - Optional logger instance
-   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
-   * @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.
+   * @param {object} options - Injected collaborators and optional factory overrides
+   * @param {object} [options.logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [options.tracer] - Optional tracer for distributed tracing
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} options.runtime - Injected runtime bag
+   * @param {(serviceName: string, logger: object, tracer: object) => object} [options.observerFn] - Observer factory
+   * @param {() => {grpc: object}} [options.grpcFn] - gRPC factory
+   * @param {(serviceName: string) => object} [options.authFn] - Auth factory
    */
-  constructor(
-    service,
-    config,
-    logger = null,
-    tracer = null,
-    observerFn = createObserver,
-    grpcFn = createGrpc,
-    authFn = createAuth,
-    runtime = null,
-  ) {
+  constructor(service, config, options = {}) {
     if (!service) throw new Error("service is required");
-
-    super(config, logger, tracer, observerFn, grpcFn, authFn);
+    const {
+      logger = null,
+      tracer = null,
+      runtime,
+      observerFn = createObserver,
+      grpcFn = createGrpc,
+      authFn = createAuth,
+    } = options;
+    if (!runtime) throw new Error("runtime is required");
+
+    super(config, runtime, logger, tracer, observerFn, grpcFn, authFn);
     this.#service = service;
-    this.#runtime = runtime ?? createDefaultRuntime();
+    this.#runtime = runtime;
   }
 
   /** Starts the gRPC server */