@nkmc/gateway 0.1.0

package/test/registry/skill-to-rpc-config.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from "vitest";
+import { skillToRpcConfig } from "../../src/registry/skill-to-config.js";
+import type { RpcSourceMeta } from "../../src/registry/types.js";
+
+const EVM_META: RpcSourceMeta = {
+  rpcUrl: "https://rpc.ankr.com/eth",
+  convention: "evm",
+  resources: [
+    {
+      name: "blocks",
+      methods: { list: "eth_blockNumber", read: "eth_getBlockByNumber" },
+    },
+    {
+      name: "balances",
+      methods: { read: "eth_getBalance" },
+    },
+  ],
+};
+
+const CRUD_META: RpcSourceMeta = {
+  rpcUrl: "https://example.com/rpc",
+  convention: "crud",
+  resources: [
+    {
+      name: "users",
+      idField: "id",
+      methods: {
+        list: "user.list",
+        read: "user.get",
+        create: "user.create",
+        write: "user.update",
+        remove: "user.delete",
+      },
+    },
+  ],
+};
+
+const RAW_META: RpcSourceMeta = {
+  rpcUrl: "https://example.com/rpc",
+  convention: "raw",
+  resources: [
+    {
+      name: "info",
+      methods: { read: "getInfo" },
+    },
+  ],
+};
+
+describe("skillToRpcConfig", () => {
+  it("should return resources matching meta input", () => {
+    const { resources } = skillToRpcConfig(EVM_META);
+    expect(resources).toHaveLength(2);
+    expect(resources[0].name).toBe("blocks");
+    expect(resources[1].name).toBe("balances");
+  });
+
+  it("should rebuild RPC methods with params callbacks", () => {
+    const { resources } = skillToRpcConfig(EVM_META);
+    const blocks = resources[0];
+    expect(blocks.methods.list).toBeDefined();
+    expect(blocks.methods.read).toBeDefined();
+    expect(blocks.methods.list!.method).toBe("eth_blockNumber");
+    expect(blocks.methods.read!.method).toBe("eth_getBlockByNumber");
+  });
+
+  it("should generate evm params for read (hex encoding)", () => {
+    const { resources } = skillToRpcConfig(EVM_META);
+    const blocks = resources[0];
+    // numeric id → hex
+    const params = blocks.methods.read!.params({ id: "100" });
+    expect(params).toEqual(["0x64", "latest"]);
+    // hex id stays as-is
+    const params2 = blocks.methods.read!.params({ id: "0xabc" });
+    expect(params2).toEqual(["0xabc", "latest"]);
+  });
+
+  it("should generate evm params for list (no params for eth_blockNumber)", () => {
+    const { resources } = skillToRpcConfig(EVM_META);
+    const blocks = resources[0];
+    const params = blocks.methods.list!.params({});
+    expect(params).toEqual([]);
+  });
+
+  it("should add evm transforms for blocks (hex block number → recent block list)", () => {
+    const { resources } = skillToRpcConfig(EVM_META);
+    const blocks = resources[0];
+    expect(blocks.transform).toBeDefined();
+    expect(blocks.transform!.list).toBeDefined();
+
+    // eth_blockNumber returns a hex string → transform to last 10 block .json files
+    const result = blocks.transform!.list!("0xa") as string[];
+    expect(result).toHaveLength(10);
+    expect(result[0]).toBe("10.json");
+    expect(result[9]).toBe("1.json");
+  });
+
+  it("should add evm transforms for balances", () => {
+    const { resources } = skillToRpcConfig(EVM_META);
+    const balances = resources[1];
+    expect(balances.transform).toBeDefined();
+    expect(balances.transform!.read).toBeDefined();
+
+    const result = balances.transform!.read!("0xde0b6b3a7640000");
+    expect(result).toEqual({ wei: "0xde0b6b3a7640000", raw: "0xde0b6b3a7640000" });
+  });
+
+  it("should generate crud params correctly", () => {
+    const { resources } = skillToRpcConfig(CRUD_META);
+    const users = resources[0];
+
+    expect(users.methods.list!.params({})).toEqual([]);
+    expect(users.methods.read!.params({ id: "123" })).toEqual(["123"]);
+    expect(users.methods.create!.params({ data: { name: "test" } })).toEqual([{ name: "test" }]);
+    expect(users.methods.write!.params({ id: "123", data: { name: "updated" } })).toEqual(["123", { name: "updated" }]);
+    expect(users.methods.remove!.params({ id: "123" })).toEqual(["123"]);
+  });
+
+  it("should preserve idField from meta", () => {
+    const { resources } = skillToRpcConfig(CRUD_META);
+    expect(resources[0].idField).toBe("id");
+  });
+
+  it("should handle raw convention with pass-through params", () => {
+    const { resources } = skillToRpcConfig(RAW_META);
+    const info = resources[0];
+    expect(info.methods.read!.method).toBe("getInfo");
+    // With id
+    expect(info.methods.read!.params({ id: "abc" })).toEqual(["abc"]);
+    // With data
+    expect(info.methods.read!.params({ data: { x: 1 } })).toEqual([{ x: 1 }]);
+    // Empty
+    expect(info.methods.read!.params({})).toEqual([]);
+  });
+
+  it("should not add transforms for non-evm conventions", () => {
+    const { resources } = skillToRpcConfig(CRUD_META);
+    expect(resources[0].transform).toBeUndefined();
+
+    const { resources: rawResources } = skillToRpcConfig(RAW_META);
+    expect(rawResources[0].transform).toBeUndefined();
+  });
+});

package/test/registry/source-refresher.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { SourceRefresher } from "../../src/registry/source-refresher.js";
+import { MemoryRegistryStore } from "../../src/registry/memory-store.js";
+import type { ServiceRecord } from "../../src/registry/types.js";
+
+function makeRecord(domain: string, overrides?: Partial<ServiceRecord>): ServiceRecord {
+  return {
+    domain,
+    name: overrides?.name ?? domain,
+    description: overrides?.description ?? `Service ${domain}`,
+    version: overrides?.version ?? "1.0",
+    roles: ["agent"],
+    skillMd: "---\nname: test\n---\n# Test\n\nTest service.\n",
+    endpoints: [],
+    isFirstParty: false,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    status: "active",
+    isDefault: true,
+    ...overrides,
+  };
+}
+
+describe("SourceRefresher", () => {
+  let store: MemoryRegistryStore;
+
+  beforeEach(() => {
+    store = new MemoryRegistryStore();
+  });
+
+  it("should not refresh without source config", async () => {
+    const record = makeRecord("test.com");
+    const refresher = new SourceRefresher(store);
+    expect(await refresher.shouldRefresh(record)).toBe(false);
+  });
+
+  it("should not refresh when interval has not elapsed", async () => {
+    const record = makeRecord("test.com", {
+      source: { type: "openapi", url: "https://test.com/spec.json", refreshInterval: 3600, lastRefresh: Date.now() },
+    });
+    const refresher = new SourceRefresher(store);
+    expect(await refresher.shouldRefresh(record)).toBe(false);
+  });
+
+  it("should refresh when interval has elapsed", async () => {
+    const record = makeRecord("test.com", {
+      source: { type: "openapi", url: "https://test.com/spec.json", refreshInterval: 1, lastRefresh: Date.now() - 2000 },
+    });
+    const refresher = new SourceRefresher(store);
+    expect(await refresher.shouldRefresh(record)).toBe(true);
+  });
+
+  it("should refresh openapi source", async () => {
+    const spec = { info: { title: "Updated", version: "2.0" }, paths: {} };
+    const mockFetch = async () => new Response(JSON.stringify(spec), { status: 200, headers: { "Content-Type": "application/json" } });
+
+    const record = makeRecord("test.com", {
+      source: { type: "openapi", url: "https://test.com/spec.json", refreshInterval: 1 },
+    });
+    await store.put("test.com", record);
+
+    const refresher = new SourceRefresher(store, mockFetch as any);
+    const updated = await refresher.refresh(record);
+    expect(updated?.name).toBe("Updated");
+    expect(updated?.source?.lastRefresh).toBeGreaterThan(0);
+  });
+
+  it("should refresh wellknown source", async () => {
+    const skillMd = '---\nname: "Refreshed"\nversion: "2.0"\nroles: [agent]\n---\n\n# Refreshed\n\nRefreshed service.\n';
+    const mockFetch = async () => new Response(skillMd, { status: 200 });
+
+    const record = makeRecord("test.com", {
+      source: { type: "wellknown", url: "https://test.com/.well-known/skill.md", refreshInterval: 1 },
+    });
+    await store.put("test.com", record);
+
+    const refresher = new SourceRefresher(store, mockFetch as any);
+    const updated = await refresher.refresh(record);
+    expect(updated?.name).toBe("Refreshed");
+  });
+
+  it("should return null for unknown source type", async () => {
+    const record = makeRecord("test.com", {
+      source: { type: "skillmd" },
+    });
+    const refresher = new SourceRefresher(store);
+    const result = await refresher.refresh(record);
+    expect(result).toBeNull();
+  });
+});

package/test/registry/virtual-files.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { VirtualFileBackend } from "../../src/registry/virtual-files.js";
+import { MemoryRegistryStore } from "../../src/registry/memory-store.js";
+import { parseSkillMd } from "../../src/registry/skill-parser.js";
+import type { FsBackend } from "@nkmc/agent-fs";
+
+const SKILL_MD = `---
+name: "Test API"
+gateway: nkmc
+version: "1.0"
+roles: [agent]
+---
+
+# Test API
+
+A test service.
+
+## API
+
+### List items
+
+\`GET /api/items\` — free
+
+### Create order
+
+\`POST /api/orders\` — 0.05 USDC / call
+`;
+
+class MockBackend implements FsBackend {
+  async list(_path: string): Promise<string[]> { return ["items/", "_api/"]; }
+  async read(_path: string): Promise<unknown> { return { mock: true }; }
+  async write(_path: string, _data: unknown): Promise<{id: string}> { return { id: "1" }; }
+  async remove(_path: string): Promise<void> {}
+  async search(_path: string, _pattern: string): Promise<unknown[]> { return []; }
+}
+
+describe("VirtualFileBackend", () => {
+  let store: MemoryRegistryStore;
+  let inner: MockBackend;
+  let backend: VirtualFileBackend;
+
+  beforeEach(async () => {
+    store = new MemoryRegistryStore();
+    const record = parseSkillMd("test-api.com", SKILL_MD);
+    await store.put("test-api.com", record);
+
+    inner = new MockBackend();
+    backend = new VirtualFileBackend({ inner, domain: "test-api.com", store });
+  });
+
+  it("should append virtual files to root listing", async () => {
+    const entries = await backend.list("/");
+    expect(entries).toContain("items/");
+    expect(entries).toContain("_api/");
+    expect(entries).toContain("_pricing.json");
+    expect(entries).toContain("_versions.json");
+  });
+
+  it("should not append virtual files to non-root listing", async () => {
+    const entries = await backend.list("/items");
+    expect(entries).not.toContain("_pricing.json");
+  });
+
+  it("should read _pricing.json", async () => {
+    const data = await backend.read("/_pricing.json") as any;
+    expect(data.domain).toBe("test-api.com");
+    expect(data.endpoints.length).toBeGreaterThan(0);
+    expect(data.endpoints[0].pricing).toBeDefined();
+  });
+
+  it("should read _versions.json", async () => {
+    const data = await backend.read("/_versions.json") as any;
+    expect(data.domain).toBe("test-api.com");
+    expect(data.versions).toHaveLength(1);
+    expect(data.versions[0].version).toBe("1.0");
+  });
+
+  it("should delegate non-virtual reads to inner backend", async () => {
+    const data = await backend.read("/items/1.json");
+    expect(data).toEqual({ mock: true });
+  });
+
+  it("should delegate write to inner backend", async () => {
+    const result = await backend.write("/items/", { name: "test" });
+    expect(result.id).toBe("1");
+  });
+
+  it("should delegate remove to inner backend", async () => {
+    await expect(backend.remove("/items/1")).resolves.toBeUndefined();
+  });
+
+  it("should delegate search to inner backend", async () => {
+    const results = await backend.search("/items", "test");
+    expect(results).toEqual([]);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts", "src/http.ts", "src/proxy.ts", "src/testing.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  clean: true,
+});