@forwardimpact/librpc 0.1.88 → 0.1.90

package/bin/fit-unary.js

@@ -13,7 +13,7 @@ const definition = {
   version: VERSION,
   description: "Make a unary gRPC call to a service",
   usage: "fit-unary <service> <method> [json-request]",
-  options: {
+  globalOptions: {
     help: { type: "boolean", short: "h", description: "Show this help" },
     version: { type: "boolean", description: "Show version" },
     json: { type: "boolean", description: "Output help as JSON" },

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@forwardimpact/librpc",
-  "version": "0.1.88",
+  "version": "0.1.90",
   "description": "gRPC framework and utilities for Guide",
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
   "type": "module",
-  "main": "index.js",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./client.js": "./src/client.js",
+    "./base.js": "./src/base.js"
+  },
   "bin": {
     "fit-unary": "./bin/fit-unary.js"
   },
+  "files": [
+    "src/**/*.js",
+    "bin/**/*.js",
+    "README.md"
+  ],
   "engines": {
     "bun": ">=1.2.0",
     "node": ">=18.0.0"

package/test/auth.test.js

@@ -1,94 +0,0 @@
-import { test, describe, beforeEach } from "node:test";
-import assert from "node:assert";
-
-import { createAuth, HmacAuth } from "../index.js";
-
-describe("Auth", () => {
-  describe("HmacAuth", () => {
-    test("should throw if secret is missing or too short", () => {
-      assert.throws(() => new HmacAuth(), /Secret must be a non-empty string/);
-      assert.throws(
-        () => new HmacAuth("short"),
-        /Secret must be at least 32 characters long/,
-      );
-    });
-
-    test("should generate and verify valid tokens", () => {
-      const secret = "test-secret-that-is-at-least-32-characters-long";
-      const auth = new HmacAuth(secret);
-      const serviceId = "test-service";
-
-      const token = auth.generateToken(serviceId);
-      assert.ok(token);
-
-      const result = auth.verifyToken(token);
-      assert.strictEqual(result.isValid, true);
-      assert.strictEqual(result.serviceId, serviceId);
-    });
-
-    test("should reject expired tokens", async () => {
-      const secret = "test-secret-that-is-at-least-32-characters-long";
-      // 1 second lifetime
-      const auth = new HmacAuth(secret, 1);
-      const serviceId = "test-service";
-
-      const token = auth.generateToken(serviceId);
-
-      // Wait for token to expire (1.1 seconds)
-      await new Promise((resolve) => setTimeout(resolve, 1100));
-
-      const result = auth.verifyToken(token);
-      assert.strictEqual(result.isValid, false);
-      assert.match(result.error, /Token has expired/);
-    });
-
-    test("should reject invalid signatures", () => {
-      const secret = "test-secret-that-is-at-least-32-characters-long";
-      const auth = new HmacAuth(secret);
-      const serviceId = "test-service";
-
-      const token = auth.generateToken(serviceId);
-
-      // Tamper with the token (it's base64 encoded)
-      const decoded = Buffer.from(token, "base64").toString("utf8");
-      const parts = decoded.split(":");
-      // Change serviceId part
-      parts[0] = "other-service";
-      const tamperedToken = Buffer.from(parts.join(":")).toString("base64");
-
-      const result = auth.verifyToken(tamperedToken);
-      assert.strictEqual(result.isValid, false);
-      assert.match(result.error, /Invalid token signature/);
-    });
-  });
-
-  describe("createAuth", () => {
-    let originalEnv;
-
-    beforeEach(() => {
-      originalEnv = process.env.SERVICE_SECRET;
-    });
-
-    test("should throw if SERVICE_SECRET is missing", () => {
-      delete process.env.SERVICE_SECRET;
-      assert.throws(
-        () => createAuth("test"),
-        /SERVICE_SECRET environment variable is required/,
-      );
-    });
-
-    test("should create Interceptor with valid secret", () => {
-      process.env.SERVICE_SECRET =
-        "test-secret-that-is-at-least-32-characters-long";
-      const interceptor = createAuth("test");
-      assert.ok(interceptor);
-
-      // Cleanup
-      if (originalEnv) {
-        process.env.SERVICE_SECRET = originalEnv;
-      } else {
-        delete process.env.SERVICE_SECRET;
-      }
-    });
-  });
-});

package/test/client.test.js

@@ -1,138 +0,0 @@
-import { test, describe, beforeEach, mock } from "node:test";
-import assert from "node:assert";
-import { PassThrough } from "stream";
-
-import { Client } from "../index.js";
-import {
-  createMockGrpcFn,
-  createMockObserverFn,
-  createMockAuthFn,
-  createMockLogger,
-} from "@forwardimpact/libharness";
-
-describe("Client", () => {
-  let mockConfig;
-  let mockGrpcFn;
-  let mockAuthFn;
-  let mockLogFn;
-  let mockObserverFn;
-  let mockClientInstance;
-
-  beforeEach(() => {
-    mockConfig = {
-      name: "memory", // Use a valid service name that exists in definitions
-      host: "0.0.0.0",
-      port: 5000,
-    };
-
-    mockClientInstance = {
-      TestMethod: mock.fn((_req, _meta, cb) => cb(null, { result: "success" })),
-      StreamMethod: mock.fn((_req, _meta) => {
-        const stream = new PassThrough({ objectMode: true });
-        process.nextTick(() => {
-          stream.emit("metadata", {});
-          stream.write({ result: "chunk1" });
-          stream.write({ result: "chunk2" });
-          stream.end();
-        });
-        return stream;
-      }),
-    };
-
-    mockGrpcFn = createMockGrpcFn({
-      grpc: {
-        Metadata: class {},
-        makeGenericClientConstructor: mock.fn(() => {
-          return function () {
-            return mockClientInstance;
-          };
-        }),
-      },
-    });
-
-    mockAuthFn = createMockAuthFn();
-
-    mockLogFn = createMockLogger();
-
-    mockObserverFn = createMockObserverFn();
-  });
-
-  test("should require config parameter", () => {
-    assert.throws(
-      () =>
-        new Client(
-          null,
-          mockLogFn,
-          null,
-          mockObserverFn,
-          mockGrpcFn,
-          mockAuthFn,
-        ),
-      /config is required/,
-    );
-  });
-
-  test("should accept valid parameters", () => {
-    const client = new Client(
-      mockConfig,
-      mockLogFn,
-      null,
-      mockObserverFn,
-      mockGrpcFn,
-      mockAuthFn,
-    );
-
-    assert.ok(client);
-    assert.strictEqual(client.config, mockConfig);
-  });
-
-  test("callUnary should execute unary call", async () => {
-    const client = new Client(
-      mockConfig,
-      mockLogFn,
-      null,
-      mockObserverFn,
-      mockGrpcFn,
-      mockAuthFn,
-    );
-
-    const response = await client.callUnary("TestMethod", { some: "data" });
-    assert.deepStrictEqual(response, { result: "success" });
-    assert.strictEqual(mockClientInstance.TestMethod.mock.callCount(), 1);
-  });
-
-  test("callStream should execute streaming call", async () => {
-    const client = new Client(
-      mockConfig,
-      mockLogFn,
-      null,
-      mockObserverFn,
-      mockGrpcFn,
-      mockAuthFn,
-    );
-
-    const stream = client.callStream("StreamMethod", { some: "data" });
-
-    const chunks = [];
-    for await (const chunk of stream) {
-      chunks.push(chunk);
-    }
-
-    assert.strictEqual(chunks.length, 2);
-    assert.deepStrictEqual(chunks[0], { result: "chunk1" });
-    assert.deepStrictEqual(chunks[1], { result: "chunk2" });
-    assert.strictEqual(mockClientInstance.StreamMethod.mock.callCount(), 1);
-  });
-
-  test("should accept tracer parameter", () => {
-    const client = new Client(
-      mockConfig,
-      mockLogFn,
-      {}, // tracer
-      mockObserverFn,
-      mockGrpcFn,
-      mockAuthFn,
-    );
-    assert.ok(client);
-  });
-});

package/test/health.test.js

@@ -1,170 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-
-import {
-  healthDefinition,
-  createHealthHandlers,
-  ServingStatus,
-  Server,
-} from "../index.js";
-import {
-  createMockConfig,
-  createMockGrpcFn,
-  createMockObserverFn,
-  createMockAuthFn,
-  createMockLogger,
-} from "@forwardimpact/libharness";
-
-describe("healthDefinition", () => {
-  test("Check has the required service definition fields", () => {
-    const check = healthDefinition.Check;
-    assert.strictEqual(check.path, "/grpc.health.v1.Health/Check");
-    assert.strictEqual(check.requestStream, false);
-    assert.strictEqual(check.responseStream, false);
-    assert.strictEqual(typeof check.requestSerialize, "function");
-    assert.strictEqual(typeof check.requestDeserialize, "function");
-    assert.strictEqual(typeof check.responseSerialize, "function");
-    assert.strictEqual(typeof check.responseDeserialize, "function");
-  });
-
-  test("request serialization round-trip with service name", () => {
-    const original = { service: "Graph" };
-    const bytes = healthDefinition.Check.requestSerialize(original);
-    const decoded = healthDefinition.Check.requestDeserialize(bytes);
-    assert.strictEqual(decoded.service, "Graph");
-  });
-
-  test("request serialization round-trip with empty service", () => {
-    const original = { service: "" };
-    const bytes = healthDefinition.Check.requestSerialize(original);
-    const decoded = healthDefinition.Check.requestDeserialize(bytes);
-    assert.strictEqual(decoded.service, "");
-  });
-
-  test("response serialization round-trip SERVING", () => {
-    const original = { status: ServingStatus.SERVING };
-    const bytes = healthDefinition.Check.responseSerialize(original);
-    const decoded = healthDefinition.Check.responseDeserialize(bytes);
-    assert.strictEqual(decoded.status, ServingStatus.SERVING);
-  });
-
-  test("response serialization round-trip UNKNOWN (proto3 default)", () => {
-    const original = { status: ServingStatus.UNKNOWN };
-    const bytes = healthDefinition.Check.responseSerialize(original);
-    const decoded = healthDefinition.Check.responseDeserialize(bytes);
-    assert.strictEqual(decoded.status, ServingStatus.UNKNOWN);
-  });
-
-  test("response serialization round-trip SERVICE_UNKNOWN", () => {
-    const original = { status: ServingStatus.SERVICE_UNKNOWN };
-    const bytes = healthDefinition.Check.responseSerialize(original);
-    const decoded = healthDefinition.Check.responseDeserialize(bytes);
-    assert.strictEqual(decoded.status, ServingStatus.SERVICE_UNKNOWN);
-  });
-});
-
-describe("createHealthHandlers", () => {
-  test("empty service name returns SERVING", (_, done) => {
-    const handlers = createHealthHandlers("Graph");
-    handlers.Check({ request: { service: "" } }, (err, response) => {
-      assert.strictEqual(err, null);
-      assert.strictEqual(response.status, ServingStatus.SERVING);
-      done();
-    });
-  });
-
-  test("matching service name returns SERVING", (_, done) => {
-    const handlers = createHealthHandlers("Graph");
-    handlers.Check({ request: { service: "Graph" } }, (err, response) => {
-      assert.strictEqual(err, null);
-      assert.strictEqual(response.status, ServingStatus.SERVING);
-      done();
-    });
-  });
-
-  test("unknown service name returns SERVICE_UNKNOWN", (_, done) => {
-    const handlers = createHealthHandlers("Graph");
-    handlers.Check({ request: { service: "Nonexistent" } }, (err, response) => {
-      assert.strictEqual(err, null);
-      assert.strictEqual(response.status, ServingStatus.SERVICE_UNKNOWN);
-      done();
-    });
-  });
-});
-
-describe("Server health registration", () => {
-  test("start() registers health service alongside application service", async () => {
-    const mockService = {
-      getHandlers: () => ({
-        TestMethod: async () => ({ result: "test" }),
-      }),
-    };
-
-    const mockConfig = createMockConfig("memory", {
-      host: "0.0.0.0",
-      port: 5000,
-    });
-    const mockGrpcFn = createMockGrpcFn();
-    const mockAuthFn = createMockAuthFn();
-    const mockLogFn = createMockLogger();
-    const mockObserverFn = createMockObserverFn(mockLogFn);
-
-    const server = new Server(
-      mockService,
-      mockConfig,
-      mockLogFn,
-      null,
-      mockObserverFn,
-      mockGrpcFn,
-      mockAuthFn,
-    );
-
-    await server.start();
-    assert.ok(server);
-  });
-
-  test("health handlers bypass auth wrapping", async () => {
-    let authCallCount = 0;
-    const trackingAuthFn = () => ({
-      createClientInterceptor: () => () => {},
-      validateCall: () => {
-        authCallCount++;
-        return { isValid: true, serviceId: "test" };
-      },
-    });
-
-    const mockService = {
-      getHandlers: () => ({
-        TestMethod: async () => ({ result: "test" }),
-      }),
-    };
-
-    const mockConfig = createMockConfig("memory", {
-      host: "0.0.0.0",
-      port: 5000,
-    });
-    const mockGrpcFn = createMockGrpcFn();
-    const mockLogFn = createMockLogger();
-    const mockObserverFn = createMockObserverFn(mockLogFn);
-
-    const server = new Server(
-      mockService,
-      mockConfig,
-      mockLogFn,
-      null,
-      mockObserverFn,
-      mockGrpcFn,
-      trackingAuthFn,
-    );
-
-    await server.start();
-
-    const handlers = createHealthHandlers("Memory");
-    const initialCount = authCallCount;
-    handlers.Check({ request: { service: "" } }, (err, response) => {
-      assert.strictEqual(err, null);
-      assert.strictEqual(response.status, ServingStatus.SERVING);
-    });
-    assert.strictEqual(authCallCount, initialCount);
-  });
-});

package/test/server.test.js

@@ -1,123 +0,0 @@
-import { test, describe, beforeEach, mock } from "node:test";
-import assert from "node:assert";
-
-import { Server } from "../index.js";
-import {
-  createMockConfig,
-  createMockGrpcFn,
-  createMockObserverFn,
-  createMockAuthFn,
-  createMockLogger,
-  createMockTracer,
-} from "@forwardimpact/libharness";
-
-describe("Server", () => {
-  let mockService;
-  let mockConfig;
-  let mockGrpcFn;
-  let mockAuthFn;
-  let mockLogFn;
-  let mockObserverFn;
-
-  beforeEach(() => {
-    mockService = {
-      getHandlers: () => ({
-        TestMethod: async (_call) => ({ result: "test" }),
-      }),
-    };
-
-    mockConfig = createMockConfig("memory", { host: "0.0.0.0", port: 5000 });
-    mockGrpcFn = createMockGrpcFn();
-    mockAuthFn = createMockAuthFn();
-    mockLogFn = createMockLogger();
-    mockObserverFn = createMockObserverFn(mockLogFn);
-  });
-
-  test("should require service parameter", () => {
-    assert.throws(
-      () =>
-        new Server(
-          null,
-          mockConfig,
-          mockLogFn,
-          null,
-          mockObserverFn,
-          mockGrpcFn,
-          mockAuthFn,
-        ),
-      /service is required/,
-    );
-  });
-
-  test("should require config parameter", () => {
-    assert.throws(
-      () =>
-        new Server(
-          mockService,
-          null,
-          mockLogFn,
-          null,
-          mockObserverFn,
-          mockGrpcFn,
-          mockAuthFn,
-        ),
-      /config is required/,
-    );
-  });
-
-  test("should accept valid parameters", () => {
-    const server = new Server(
-      mockService,
-      mockConfig,
-      mockLogFn,
-      null,
-      mockObserverFn,
-      mockGrpcFn,
-      mockAuthFn,
-    );
-
-    assert.ok(server);
-    assert.strictEqual(server.config, mockConfig);
-  });
-
-  test("should call service methods during setup", async () => {
-    const getHandlersSpy = mock.fn(() => ({
-      TestMethod: async () => ({ result: "test" }),
-    }));
-
-    const spiedService = {
-      getHandlers: getHandlersSpy,
-    };
-
-    const server = new Server(
-      spiedService,
-      mockConfig,
-      mockLogFn,
-      null,
-      mockObserverFn,
-      mockGrpcFn,
-      mockAuthFn,
-    );
-
-    // Start the server to trigger setup
-    await server.start();
-
-    assert.strictEqual(getHandlersSpy.mock.callCount(), 1);
-  });
-
-  test("should accept tracer parameter", () => {
-    const mockTracer = createMockTracer();
-
-    const server = new Server(
-      mockService,
-      mockConfig,
-      mockLogFn,
-      mockTracer,
-      mockObserverFn,
-      mockGrpcFn,
-      mockAuthFn,
-    );
-
-    assert.ok(server);
-  });
-});