@covenant-rpc/server 0.1.3

package/tests/procedure.test.ts

@@ -0,0 +1,238 @@
+import { z } from "zod";
+import { test, expect } from "bun:test";
+import { declareCovenant, query, mutation } from "@covenant-rpc/core";
+import { CovenantServer } from "../lib/server";
+import { emptyServerToSidekick } from "../lib/interfaces/empty";
+import { emptyClientToSidekick } from "@covenant-rpc/client";
+import { CovenantClient } from "@covenant-rpc/client";
+import { directClientToServer } from "../lib/interfaces/direct";
+
+
+test("simple procedure", async () => {
+  const covenant = declareCovenant({
+    procedures: {
+      helloWorld: query({
+        input: z.object({
+          name: z.string(),
+        }),
+        output: z.object({
+          message: z.string(),
+        })
+      })
+    },
+    channels: {},
+  });
+
+  const server = new CovenantServer(covenant, {
+    contextGenerator: () => undefined,
+    derivation: () => { },
+    sidekickConnection: emptyServerToSidekick(),
+  });
+
+  server.defineProcedure("helloWorld", {
+    resources: (i) => {
+      return [`greeting/${i.inputs.name}`];
+    },
+    procedure: ({ inputs }) => {
+      return {
+        message: `Hello, ${inputs.name}`,
+      }
+    },
+  })
+
+  const client = new CovenantClient(covenant, {
+    sidekickConnection: emptyClientToSidekick(),
+    serverConnection: directClientToServer(server, {}),
+  });
+
+  const result = await client.query("helloWorld", {
+    name: "Someone",
+  });
+
+  expect(result.success).toBe(true);
+  expect(result.error).toBe(null);
+  expect(result.data).toEqual({
+    message: "Hello, Someone",
+  });
+  expect(result.resources).toEqual(["greeting/Someone"]);
+});
+
+const widgetSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  price: z.number(),
+});
+type Widget = z.infer<typeof widgetSchema>;
+
+test("procedure with local listen", async () => {
+
+  const currentWidgets: Widget[] = [
+    {
+      id: 1,
+      name: "Widget one",
+      price: 1000000,
+    },
+  ]
+
+  const covenant = declareCovenant({
+    procedures: {
+      getWidgets: query({
+        input: z.null(),
+        output: z.array(widgetSchema),
+      }),
+      addWidget: mutation({
+        input: widgetSchema,
+        output: z.null(),
+      })
+    },
+    channels: {},
+  });
+
+  const server = new CovenantServer(covenant, {
+    contextGenerator: () => null,
+    derivation: () => { },
+    sidekickConnection: emptyServerToSidekick(),
+  });
+
+  server.defineProcedure("addWidget", {
+    procedure: ({ inputs }) => {
+      currentWidgets.push(inputs);
+      return null;
+    },
+    resources: () => {
+      return ["widgets"];
+    },
+  });
+
+  server.defineProcedure("getWidgets", {
+    procedure: () => {
+      return currentWidgets;
+    },
+    resources: () => {
+      return ["widgets"];
+    },
+  });
+
+  const client = new CovenantClient(covenant, {
+    sidekickConnection: emptyClientToSidekick(),
+    serverConnection: directClientToServer(server, {}),
+  });
+
+  // this is really ugly
+  const p = new Promise<void>(async (resolveOuter) => {
+
+    await new Promise<void>(async (resolve) => {
+      let times = 0;
+      const unsubscribe = client.listen("getWidgets", null, (result) => {
+        times += 1;
+        expect(result.resources).toEqual(["widgets"]);
+        expect(result.error).toBe(null);
+        expect(result.success).toBe(true);
+
+        switch (times) {
+          case 1:
+            expect(result.data).toEqual([
+              {
+                id: 1,
+                name: "Widget one",
+                price: 1000000,
+              },
+            ]);
+            resolveOuter();
+            break;
+          case 2:
+            expect(result.data).toEqual([
+              {
+                id: 1,
+                name: "Widget one",
+                price: 1000000,
+              },
+              {
+                id: 2,
+                name: "Widget two",
+                price: 1000000,
+              },
+            ])
+
+            resolve();
+            unsubscribe();
+            break;
+        }
+      });
+    });
+    await p;
+
+    client.mutate("addWidget", {
+      id: 2,
+      name: "Widget two",
+      price: 1000000,
+    });
+  });
+});
+
+test("procedure error handling", async () => {
+  const covenant = declareCovenant({
+    procedures: {
+      failingProcedure: query({
+        input: z.object({
+          shouldFail: z.boolean(),
+        }),
+        output: z.object({
+          message: z.string(),
+        })
+      })
+    },
+    channels: {},
+  });
+
+  const server = new CovenantServer(covenant, {
+    contextGenerator: () => undefined,
+    derivation: () => { },
+    sidekickConnection: emptyServerToSidekick(),
+  });
+
+  server.defineProcedure("failingProcedure", {
+    resources: () => ["test"],
+    procedure: ({ inputs, error }) => {
+      if (inputs.shouldFail) {
+        error("This procedure failed intentionally", 400);
+      }
+      return {
+        message: "Success!",
+      }
+    },
+  })
+
+  const client = new CovenantClient(covenant, {
+    sidekickConnection: emptyClientToSidekick(),
+    serverConnection: directClientToServer(server, {}),
+  });
+
+  // Test successful case
+  const successResult = await client.query("failingProcedure", {
+    shouldFail: false,
+  });
+
+  expect(successResult.success).toBe(true);
+  expect(successResult.error).toBe(null);
+  expect(successResult.data).toEqual({
+    message: "Success!",
+  });
+  expect(successResult.resources).toEqual(["test"]);
+
+  // Test error case
+  const errorResult = await client.query("failingProcedure", {
+    shouldFail: true,
+  });
+
+  expect(errorResult.success).toBe(false);
+  expect(errorResult.data).toBe(null);
+  expect(errorResult.resources).toBe(null);
+  expect(errorResult.error).toEqual({
+    message: "This procedure failed intentionally",
+    code: 400,
+  });
+});
+
+// TODO: test procedure with context
+

package/tests/sidekick.test.ts

@@ -0,0 +1,23 @@
+import { Sidekick } from "../lib/sidekick";
+import { test, expect, mock } from "bun:test";
+import type { SidekickOutgoingMessage } from "../lib/sidekick/protocol";
+
+
+test("resource updating", () => {
+  // could be anything we just need to assert the calls
+  const publishFunction = mock(async (topic: string, message: SidekickOutgoingMessage) => {});
+
+  const sidekick = new Sidekick(publishFunction);
+
+  sidekick.updateResources(["hello", "world"]);
+  expect(publishFunction.mock.calls).toEqual([
+    ["resource:hello", {
+      type: "updated",
+      resource: "hello",
+    }],
+    ["resource:world", {
+      type: "updated",
+      resource: "world",
+    }],
+  ]);
+});

package/tests/validation-types.test.ts

@@ -0,0 +1,122 @@
+import { test } from "bun:test";
+import { v } from "@covenant-rpc/core/validation";
+
+// Type-level testing helper
+type Expect<T extends true> = T;
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+
+test("type inference works correctly", () => {
+  // Basic type inference
+  type BoolInfer = v.Infer<ReturnType<typeof v.bool>>;
+  type NumberInfer = v.Infer<ReturnType<typeof v.number>>;
+  type StringInfer = v.Infer<ReturnType<typeof v.string>>;
+
+  type _BoolTest = Expect<Equal<BoolInfer, boolean>>;
+  type _NumberTest = Expect<Equal<NumberInfer, number>>;
+  type _StringTest = Expect<Equal<StringInfer, string>>;
+
+  // Optional type inference
+  type OptionalStringInfer = v.Infer<ReturnType<typeof v.optional<string>>>;
+  type _OptionalTest = Expect<Equal<OptionalStringInfer, string | undefined>>;
+
+  // Nullable type inference
+  type NullableStringInfer = v.Infer<ReturnType<typeof v.nullable<string>>>;
+  type _NullableTest = Expect<Equal<NullableStringInfer, string | null>>;
+
+  // Union type inference
+  const stringOrNumber = v.union(v.string(), v.number());
+  type UnionInfer = v.Infer<typeof stringOrNumber>;
+  type _UnionTest = Expect<Equal<UnionInfer, string | number>>;
+
+  // Literal type inference
+  const successLiteral = v.literal("success");
+  const numberLiteral = v.literal(42);
+  const boolLiteral = v.literal(true);
+  const nullLiteral = v.literal(null);
+
+  type SuccessLiteralInfer = v.Infer<typeof successLiteral>;
+  type NumberLiteralInfer = v.Infer<typeof numberLiteral>;
+  type BoolLiteralInfer = v.Infer<typeof boolLiteral>;
+  type NullLiteralInfer = v.Infer<typeof nullLiteral>;
+
+  type _SuccessLiteralTest = Expect<Equal<SuccessLiteralInfer, "success">>;
+  type _NumberLiteralTest = Expect<Equal<NumberLiteralInfer, 42>>;
+  type _BoolLiteralTest = Expect<Equal<BoolLiteralInfer, true>>;
+  type _NullLiteralTest = Expect<Equal<NullLiteralInfer, null>>;
+
+  // Object type inference
+  const userValidator = v.obj({
+    id: v.number(),
+    name: v.string(),
+    active: v.bool()
+  });
+
+  type UserInfer = v.Infer<typeof userValidator>;
+  type ExpectedUser = {
+    id: number;
+    name: string;
+    active: boolean;
+  };
+  type _UserTest = Expect<Equal<UserInfer, ExpectedUser>>;
+
+  // Complex nested object with optional and nullable fields
+  const complexValidator = v.obj({
+    status: v.union(v.literal("success"), v.literal("error"), v.literal("pending")),
+    data: v.optional(v.obj({
+      id: v.number(),
+      name: v.string(),
+      tags: v.nullable(v.union(v.string(), v.number()))
+    })),
+    metadata: v.nullable(v.obj({
+      timestamp: v.number(),
+      source: v.literal("api")
+    }))
+  });
+
+  type ComplexInfer = v.Infer<typeof complexValidator>;
+  type ExpectedComplex = {
+    status: "success" | "error" | "pending";
+    data: {
+      id: number;
+      name: string;
+      tags: string | number | null;
+    } | undefined;
+    metadata: {
+      timestamp: number;
+      source: "api";
+    } | null;
+  };
+  type _ComplexTest = Expect<Equal<ComplexInfer, ExpectedComplex>>;
+
+  // Multiple union literals
+  const statusValidator = v.union(
+    v.literal("loading"),
+    v.literal("success"), 
+    v.literal("error")
+  );
+  type StatusInfer = v.Infer<typeof statusValidator>;
+  type _StatusTest = Expect<Equal<StatusInfer, "loading" | "success" | "error">>;
+
+  // Mixed union types
+  const mixedValidator = v.union(
+    v.literal("none"),
+    v.number(),
+    v.obj({ type: v.literal("object") })
+  );
+  type MixedInfer = v.Infer<typeof mixedValidator>;
+  type ExpectedMixed = "none" | number | { type: "object" };
+  type _MixedTest = Expect<Equal<MixedInfer, ExpectedMixed>>;
+
+  // Array type inference
+  const stringArrayValidator = v.array(v.string());
+  const numberArrayValidator = v.array(v.number());
+  const objArrayValidator = v.array(v.obj({ id: v.number() }));
+  
+  type StringArrayInfer = v.Infer<typeof stringArrayValidator>;
+  type NumberArrayInfer = v.Infer<typeof numberArrayValidator>;
+  type ObjArrayInfer = v.Infer<typeof objArrayValidator>;
+  
+  type _StringArrayTest = Expect<Equal<StringArrayInfer, string[]>>;
+  type _NumberArrayTest = Expect<Equal<NumberArrayInfer, number[]>>;
+  type _ObjArrayTest = Expect<Equal<ObjArrayInfer, { id: number }[]>>;
+});

package/tests/validation.test.ts

@@ -0,0 +1,144 @@
+import { test, expect } from "bun:test";
+import { v } from "@covenant-rpc/core/validation";
+
+test("bool validator", () => {
+  const validator = v.bool();
+  expect(validator(true)).toBe(true);
+  expect(validator(false)).toBe(true);
+  expect(validator("true")).toBe(false);
+  expect(validator(1)).toBe(false);
+  expect(validator(null)).toBe(false);
+});
+
+test("number validator", () => {
+  const validator = v.number();
+  expect(validator(42)).toBe(true);
+  expect(validator(3.14)).toBe(true);
+  expect(validator("42")).toBe(false);
+  expect(validator(true)).toBe(false);
+  expect(validator(null)).toBe(false);
+});
+
+test("string validator", () => {
+  const validator = v.string();
+  expect(validator("hello")).toBe(true);
+  expect(validator("")).toBe(true);
+  expect(validator(42)).toBe(false);
+  expect(validator(null)).toBe(false);
+});
+
+test("optional validator", () => {
+  const validator = v.optional(v.string());
+  expect(validator("hello")).toBe(true);
+  expect(validator(undefined)).toBe(true);
+  expect(validator(null)).toBe(false);
+  expect(validator(42)).toBe(false);
+});
+
+test("nullable validator", () => {
+  const validator = v.nullable(v.string());
+  expect(validator("hello")).toBe(true);
+  expect(validator(null)).toBe(true);
+  expect(validator(undefined)).toBe(false);
+  expect(validator(42)).toBe(false);
+});
+
+test("union validator", () => {
+  const validator = v.union(v.string(), v.number());
+  expect(validator("hello")).toBe(true);
+  expect(validator(42)).toBe(true);
+  expect(validator(true)).toBe(false);
+  expect(validator(null)).toBe(false);
+});
+
+test("literal validator", () => {
+  const stringLiteral = v.literal("success");
+  expect(stringLiteral("success")).toBe(true);
+  expect(stringLiteral("fail")).toBe(false);
+  expect(stringLiteral(null)).toBe(false);
+
+  const numberLiteral = v.literal(42);
+  expect(numberLiteral(42)).toBe(true);
+  expect(numberLiteral(43)).toBe(false);
+
+  const boolLiteral = v.literal(true);
+  expect(boolLiteral(true)).toBe(true);
+  expect(boolLiteral(false)).toBe(false);
+
+  const nullLiteral = v.literal(null);
+  expect(nullLiteral(null)).toBe(true);
+  expect(nullLiteral(undefined)).toBe(false);
+});
+
+test("obj validator", () => {
+  const validator = v.obj({
+    name: v.string(),
+    age: v.number(),
+    active: v.bool()
+  });
+
+  expect(validator({
+    name: "John",
+    age: 30,
+    active: true
+  })).toBe(true);
+
+  expect(validator({
+    name: "John",
+    age: "30",
+    active: true
+  })).toBe(false);
+
+  expect(validator({
+    name: "John",
+    age: 30
+  })).toBe(false);
+
+  expect(validator(null)).toBe(false);
+  expect(validator("not an object")).toBe(false);
+});
+
+test("complex nested validation", () => {
+  const validator = v.obj({
+    status: v.union(v.literal("success"), v.literal("error")),
+    data: v.optional(v.obj({
+      id: v.number(),
+      name: v.string()
+    })),
+    metadata: v.nullable(v.obj({
+      timestamp: v.number()
+    }))
+  });
+
+  expect(validator({
+    status: "success",
+    data: { id: 1, name: "test" },
+    metadata: { timestamp: 123456 }
+  })).toBe(true);
+
+  expect(validator({
+    status: "error",
+    data: undefined,
+    metadata: null
+  })).toBe(true);
+
+  expect(validator({
+    status: "pending",
+    data: undefined,
+    metadata: null
+  })).toBe(false);
+});
+
+test("array validator", () => {
+  const stringArrayValidator = v.array(v.string());
+  expect(stringArrayValidator(["hello", "world"])).toBe(true);
+  expect(stringArrayValidator([])).toBe(true);
+  expect(stringArrayValidator(["hello", 42])).toBe(false);
+  expect(stringArrayValidator("not an array")).toBe(false);
+  expect(stringArrayValidator(null)).toBe(false);
+
+  const numberArrayValidator = v.array(v.number());
+  expect(numberArrayValidator([1, 2, 3])).toBe(true);
+  expect(numberArrayValidator([1, "2", 3])).toBe(false);
+});
+