@forwardimpact/librpc 0.1.105 → 0.1.107

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.105",
+  "version": "0.1.107",
   "description": "gRPC server and client framework — ship service endpoints without reimplementing transport.",
   "keywords": [
     "grpc",
@@ -44,6 +44,8 @@
     "README.md"
   ],
   "scripts": {
+    "prepack": "node -e \"const fs=require('node:fs');fs.rmSync('src/generated',{recursive:true,force:true});fs.cpSync('../../generated','src/generated',{recursive:true})\"",
+    "postpack": "node -e \"const fs=require('node:fs');fs.rmSync('src/generated',{recursive:true,force:true});fs.symlinkSync('../../../generated','src/generated','dir')\"",
     "test": "bun test test/*.test.js"
   },
   "dependencies": {

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/generated/definitions/bridge.js

@@ -0,0 +1,260 @@
+import { bridge, common } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Bridge
+ * Generated at build time
+ */
+export const BridgeServiceDefinition = {
+  LoadDiscussion: {
+    path: '/bridge.Bridge/LoadDiscussion',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.LoadDiscussionRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.LoadDiscussionRequest.toObject(
+        bridge.LoadDiscussionRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.Discussion.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.Discussion.toObject(
+        bridge.Discussion.decode(value)
+      );
+    },
+  },
+  LoadDiscussionByCorrelation: {
+    path: '/bridge.Bridge/LoadDiscussionByCorrelation',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.LoadByCorrelationRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.LoadByCorrelationRequest.toObject(
+        bridge.LoadByCorrelationRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.Discussion.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.Discussion.toObject(
+        bridge.Discussion.decode(value)
+      );
+    },
+  },
+  ListOpenRecesses: {
+    path: '/bridge.Bridge/ListOpenRecesses',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.ListOpenRecessesRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.ListOpenRecessesRequest.toObject(
+        bridge.ListOpenRecessesRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.OpenRecessList.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.OpenRecessList.toObject(
+        bridge.OpenRecessList.decode(value)
+      );
+    },
+  },
+  SaveDiscussion: {
+    path: '/bridge.Bridge/SaveDiscussion',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.Discussion.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.Discussion.toObject(
+        bridge.Discussion.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  HasOrigin: {
+    path: '/bridge.Bridge/HasOrigin',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.OriginKey.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.OriginKey.toObject(
+        bridge.OriginKey.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.HasOriginResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.HasOriginResponse.toObject(
+        bridge.HasOriginResponse.decode(value)
+      );
+    },
+  },
+  RecordOrigin: {
+    path: '/bridge.Bridge/RecordOrigin',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.Origin.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.Origin.toObject(
+        bridge.Origin.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  Sweep: {
+    path: '/bridge.Bridge/Sweep',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.SweepRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.SweepRequest.toObject(
+        bridge.SweepRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.SweepResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.SweepResponse.toObject(
+        bridge.SweepResponse.decode(value)
+      );
+    },
+  },
+  PutPendingDispatch: {
+    path: '/bridge.Bridge/PutPendingDispatch',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.PutPendingDispatchRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.PutPendingDispatchRequest.toObject(
+        bridge.PutPendingDispatchRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  ResolvePendingDispatch: {
+    path: '/bridge.Bridge/ResolvePendingDispatch',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.ResolvePendingDispatchRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.ResolvePendingDispatchRequest.toObject(
+        bridge.ResolvePendingDispatchRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.PendingDispatch.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.PendingDispatch.toObject(
+        bridge.PendingDispatch.decode(value)
+      );
+    },
+  },
+  VerifyPendingDispatch: {
+    path: '/bridge.Bridge/VerifyPendingDispatch',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.VerifyPendingDispatchRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.VerifyPendingDispatchRequest.toObject(
+        bridge.VerifyPendingDispatchRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  EnqueueInbox: {
+    path: '/bridge.Bridge/EnqueueInbox',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.EnqueueInboxRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.EnqueueInboxRequest.toObject(
+        bridge.EnqueueInboxRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+  DrainInbox: {
+    path: '/bridge.Bridge/DrainInbox',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(bridge.DrainInboxRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return bridge.DrainInboxRequest.toObject(
+        bridge.DrainInboxRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(bridge.InboxMessages.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return bridge.InboxMessages.toObject(
+        bridge.InboxMessages.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/embedding.js

@@ -0,0 +1,29 @@
+import { embedding } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Embedding
+ * Generated at build time
+ */
+export const EmbeddingServiceDefinition = {
+  CreateEmbeddings: {
+    path: '/embedding.Embedding/CreateEmbeddings',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(embedding.EmbeddingsRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return embedding.EmbeddingsRequest.toObject(
+        embedding.EmbeddingsRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(embedding.EmbeddingsResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return embedding.EmbeddingsResponse.toObject(
+        embedding.EmbeddingsResponse.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/exports.js

@@ -0,0 +1,43 @@
+// THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+// Generated by scripts/codegen.js
+
+// Service Definitions
+export { BridgeServiceDefinition } from "./bridge.js";
+export { EmbeddingServiceDefinition } from "./embedding.js";
+export { GhserverServiceDefinition } from "./ghserver.js";
+export { GhuserServiceDefinition } from "./ghuser.js";
+export { GraphServiceDefinition } from "./graph.js";
+export { MapServiceDefinition } from "./map.js";
+export { PathwayServiceDefinition } from "./pathway.js";
+export { TenancyServiceDefinition } from "./tenancy.js";
+export { TraceServiceDefinition } from "./trace.js";
+export { VectorServiceDefinition } from "./vector.js";
+
+// Import service definitions to make them available for aggregation
+import { BridgeServiceDefinition } from "./bridge.js";
+import { EmbeddingServiceDefinition } from "./embedding.js";
+import { GhserverServiceDefinition } from "./ghserver.js";
+import { GhuserServiceDefinition } from "./ghuser.js";
+import { GraphServiceDefinition } from "./graph.js";
+import { MapServiceDefinition } from "./map.js";
+import { PathwayServiceDefinition } from "./pathway.js";
+import { TenancyServiceDefinition } from "./tenancy.js";
+import { TraceServiceDefinition } from "./trace.js";
+import { VectorServiceDefinition } from "./vector.js";
+
+// Aggregate exports for convenience
+export const definitions = {
+  bridge: BridgeServiceDefinition,
+  embedding: EmbeddingServiceDefinition,
+  ghserver: GhserverServiceDefinition,
+  ghuser: GhuserServiceDefinition,
+  graph: GraphServiceDefinition,
+  map: MapServiceDefinition,
+  pathway: PathwayServiceDefinition,
+  tenancy: TenancyServiceDefinition,
+  trace: TraceServiceDefinition,
+  vector: VectorServiceDefinition,
+};
+
+// Re-export as default for dynamic importing
+export default definitions;

package/src/generated/definitions/ghserver.js

@@ -0,0 +1,29 @@
+import { ghserver } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Ghserver
+ * Generated at build time
+ */
+export const GhserverServiceDefinition = {
+  MintInstallationToken: {
+    path: '/ghserver.Ghserver/MintInstallationToken',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghserver.MintRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghserver.MintRequest.toObject(
+        ghserver.MintRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghserver.MintResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghserver.MintResponse.toObject(
+        ghserver.MintResponse.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/ghuser.js

@@ -0,0 +1,113 @@
+import { ghuser, common } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Ghuser
+ * Generated at build time
+ */
+export const GhuserServiceDefinition = {
+  Begin: {
+    path: '/ghuser.Ghuser/Begin',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.BeginRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.BeginRequest.toObject(
+        ghuser.BeginRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghuser.BeginResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghuser.BeginResponse.toObject(
+        ghuser.BeginResponse.decode(value)
+      );
+    },
+  },
+  Complete: {
+    path: '/ghuser.Ghuser/Complete',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.CompleteRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.CompleteRequest.toObject(
+        ghuser.CompleteRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghuser.CompleteResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghuser.CompleteResponse.toObject(
+        ghuser.CompleteResponse.decode(value)
+      );
+    },
+  },
+  Redeem: {
+    path: '/ghuser.Ghuser/Redeem',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.RedeemRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.RedeemRequest.toObject(
+        ghuser.RedeemRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghuser.RedeemResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghuser.RedeemResponse.toObject(
+        ghuser.RedeemResponse.decode(value)
+      );
+    },
+  },
+  GetToken: {
+    path: '/ghuser.Ghuser/GetToken',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.GetTokenRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.GetTokenRequest.toObject(
+        ghuser.GetTokenRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(ghuser.GetTokenResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return ghuser.GetTokenResponse.toObject(
+        ghuser.GetTokenResponse.decode(value)
+      );
+    },
+  },
+  Revoke: {
+    path: '/ghuser.Ghuser/Revoke',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(ghuser.RevokeRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return ghuser.RevokeRequest.toObject(
+        ghuser.RevokeRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(common.Empty.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return common.Empty.toObject(
+        common.Empty.decode(value)
+      );
+    },
+  },
+};