WRNexusJS/packages/rpc/test/integration.test.ts

import { afterEach, describe, expect, test } from "bun:test";
import type { Context } from "@wrnexus/core";
import { v } from "@wrnexus/validation";
import { serviceClient } from "../src/client.ts";
import { defineService, procedure } from "../src/contract.ts";
import { RPC_ERROR_CODES } from "../src/errors.ts";
import { httpTransport } from "../src/http.ts";
import { implement } from "../src/server.ts";
import { inProcessTransport } from "../src/transport.ts";
import { handleRpcRequest } from "../../dev-server/src/rpc-dispatch.ts";

const originalRpcSecret = process.env.WRNEXUS_RPC_SECRET;
const originalAppName = process.env.WRNEXUS_APP_NAME;
afterEach(() => {
  if (originalRpcSecret === undefined) delete process.env.WRNEXUS_RPC_SECRET;
  else process.env.WRNEXUS_RPC_SECRET = originalRpcSecret;
  if (originalAppName === undefined) delete process.env.WRNEXUS_APP_NAME;
  else process.env.WRNEXUS_APP_NAME = originalAppName;
});

const billing = defineService({
  name: "billing",
  procedures: {
    createInvoice: procedure
      .input(v.object({ amountCents: v.number() }))
      .output<{ invoiceId: string; forSubject: string }>()
      .permission("invoice:create")
      .build(),
  },
});

function wire(allowed: boolean) {
  const service = implement(
    billing,
    {
      createInvoice: async ({ amountCents }, ctx) => ({
        invoiceId: `inv_${amountCents}`,
        forSubject: ctx.subject?.subjectId ?? "anon",
      }),
    },
    { selfApp: "billing", checkPermission: async () => allowed },
  );
  return inProcessTransport({
    "billing/createInvoice": (payload, identity) =>
      service.invoke("createInvoice", payload, identity),
  });
}

function httpWire(allowed: boolean) {
  const service = implement(
    billing,
    {
      createInvoice: async ({ amountCents }, ctx) => ({
        invoiceId: `inv_${amountCents}`,
        forSubject: ctx.subject?.subjectId ?? "anon",
      }),
    },
    { selfApp: "billing", checkPermission: async () => allowed },
  );
  return httpTransport({
    resolveOrigin: () => "http://billing.internal",
    fetch: (async (input: RequestInfo | URL, init?: RequestInit) => {
      const request = new Request(input, init);
      return (await handleRpcRequest(
        request,
        new URL(request.url),
        new Map([["billing", service]]),
      ))!;
    }) as typeof fetch,
  });
}

describe("RPC integration", () => {
  test("propagates identity and validates the callee permission", async () => {
    process.env.WRNEXUS_RPC_SECRET = "test-rpc-secret-at-least-32-chars-long";
    process.env.WRNEXUS_APP_NAME = "web";
    const client = serviceClient(billing, {
      app: "billing",
      as: { user: { id: "u1" }, tenant: { id: "acme" }, locals: {} } as unknown as Context,
      transport: wire(true),
    });
    expect(await client.createInvoice({ amountCents: 250 })).toEqual({
      invoiceId: "inv_250",
      forSubject: "u1",
    });
  });

  test("denies when the callee permission check refuses", async () => {
    process.env.WRNEXUS_RPC_SECRET = "test-rpc-secret-at-least-32-chars-long";
    process.env.WRNEXUS_APP_NAME = "web";
    const client = serviceClient(billing, {
      app: "billing",
      as: { user: { id: "u1" }, locals: {} } as unknown as Context,
      transport: wire(false),
    });
    await expect(client.createInvoice({ amountCents: 1 })).rejects.toMatchObject({
      code: RPC_ERROR_CODES.denied,
    });
  });

  test("uses the real HTTP transport and private dispatcher end to end", async () => {
    process.env.WRNEXUS_RPC_SECRET = "test-rpc-secret-at-least-32-chars-long";
    process.env.WRNEXUS_APP_NAME = "web";
    const client = serviceClient(billing, {
      app: "billing",
      as: { user: { id: "u1" }, locals: {} } as unknown as Context,
      transport: httpWire(true),
    });
    expect(await client.createInvoice({ amountCents: 7 })).toEqual({
      invoiceId: "inv_7",
      forSubject: "u1",
    });
    await expect(client.createInvoice({ amountCents: "bad" } as never)).rejects.toMatchObject({
      code: RPC_ERROR_CODES.invalid,
    });
  });
});