Convex MCP server

import { GenericId } from "../values/index.js"; import { describe, test, expect } from "vitest"; import { assert, Equals } from "../test/type_testing.js"; import { v, Infer } from "../values/validator.js"; describe("Validators", () => { test("optional types don't lose specificity", () => { const a = v.optional(v.id("a")); const b = v.optional(v.null()); const c = v.optional(v.number()); const d = v.optional(v.int64()); const e = v.optional(v.boolean()); const f = v.optional(v.string()); const g = v.optional(v.bytes()); const h = v.optional(v.literal("a")); const i = v.optional(v.array(v.string())); const j = v.optional(v.object({ a: v.string() })); const k = v.optional(v.record(v.string(), v.string())); const l = v.optional(v.union(v.string(), v.number())); // Optional makes types a union with undefined. assert<Equals<Infer<typeof a>, GenericId<"a"> | undefined>>(); assert<Equals<Infer<typeof b>, null | undefined>>(); assert<Equals<Infer<typeof c>, number | undefined>>(); assert<Equals<Infer<typeof d>, bigint | undefined>>(); assert<Equals<Infer<typeof e>, boolean | undefined>>(); assert<Equals<Infer<typeof f>, string | undefined>>(); assert<Equals<Infer<typeof g>, ArrayBuffer | undefined>>(); assert<Equals<Infer<typeof h>, "a" | undefined>>(); assert<Equals<Infer<typeof i>, string[] | undefined>>(); assert<Equals<Infer<typeof j>, { a: string } | undefined>>(); assert<Equals<Infer<typeof k>, Record<string, string> | undefined>>(); assert<Equals<Infer<typeof l>, string | number | undefined>>(); // Note: this test does not actually verify this property unless // the tsconfig.json option `"exactOptionalPropertyTypes": true` is used. const _optionals = v.object({ a, b, c, d, e, f, g, h, i, j, k, l }); assert< Equals< Infer<typeof _optionals>, { a?: GenericId<"a">; b?: null; c?: number; d?: bigint; e?: boolean; f?: string; g?: ArrayBuffer; h?: "a"; i?: string[]; j?: { a: string }; k?: Record<string, string>; l?: string | number; } > >(); }); test("Most validators don't accept optional validators as children", () => { const optional = v.optional(v.string()); const required = v.string(); v.object({ optional }); v.array(required); // @ts-expect-error This should be an error v.array(optional); v.record(required, required); const invalidRecordError = "Record validator cannot have optional "; // @ts-expect-error This should be an error expect(() => v.record(required, optional)).toThrowError( invalidRecordError + "values", ); // @ts-expect-error This should be an error expect(() => v.record(optional, required)).toThrowError( invalidRecordError + "keys", ); // @ts-expect-error This should be an error expect(() => v.record(optional, optional)).toThrowError( invalidRecordError + "keys", ); v.union(required, required); // @ts-expect-error This should be an error v.union(optional, optional); // @ts-expect-error This should be an error v.union(required, optional); // @ts-expect-error This should be an error v.union(optional, required); }); test("Record validators cannot have non-strings as arguments", () => { v.record(v.id("table1"), v.string()); v.record(v.union(v.id("table1"), v.id("table2")), v.string()); // @ts-expect-error This should be an error v.record(v.number(), v.string()); // @ts-expect-error This should be an error v.record(v.int64(), v.string()); // @ts-expect-error This should be an error v.record(v.float64(), v.string()); // @ts-expect-error This should be an error v.record(v.null(), v.string()); // @ts-expect-error This should be an error v.record(v.boolean(), v.string()); // These patterns will compile, but will be rejected by the server v.record(v.union(v.literal("abc"), v.literal("def")), v.string()); v.record(v.union(v.id("table1"), v.literal("def")), v.string()); }); test("complex types look good", () => { const _obj = v.object({ a: v.record(v.string(), v.string()), b: v.string(), c: v.union(v.string(), v.union(v.string(), v.number())), d: v.object({ foo: v.string(), bar: v.optional(v.number()) }), }); type Expected = { a: Record<string, string>; b: string; c: string | number; d: { bar?: number | undefined; foo: string; }; }; assert<Equals<Infer<typeof _obj>, Expected>>(); }); }); describe("invalid validators fail when constructed obviously wrongly", () => { describe("easy ones", () => { test("v.id", () => { expect(() => { (v as any).id(); }).toThrow(); expect(() => { v.id({} as any); }).toThrow(); expect(() => { v.id({} as any); }).toThrow(); }); // no tests for v.null, number, floag64, bigint, in64, boolean, string, or bytes test("v.literal", () => { expect(() => { (v as any).literal(); }).toThrow(); expect(() => { v.literal({} as any); }).toThrow(); }); }); test("v.object", () => { expect(() => { (v as any).object(); }).toThrow(); expect(() => { v.object({ a: {} } as any); }).toThrow(); expect(() => { v.object({}); }).not.toThrow(); expect(() => { v.object({ a: undefined as any }); }).toThrow(); }); test("v.object regression test", () => { expect(() => { // real issue from the wild v.object({ a: v.string as any }); }).toThrow(); }); test("v.record", () => { expect(() => { (v as any).record(); }).toThrow(); expect(() => { v.record({} as any, {} as any); }).toThrow(); }); test("v.union", () => { expect(() => { v.union({} as any, {} as any); }).toThrow(); }); }); describe("v.object utility methods", () => { describe("omit", () => { test("omits specified fields from VObject", () => { const original = v.object({ a: v.string(), b: v.number(), c: v.boolean(), }); const omitted = original.omit("b"); // Type checks assert< Equals< Infer<typeof omitted>, { a: string; c: boolean; } > >(); // Runtime checks expect(omitted.fields).toHaveProperty("a"); expect(omitted.fields).toHaveProperty("c"); expect(omitted.fields).not.toHaveProperty("b"); expect(omitted.isOptional).toBe("required"); }); test("omits multiple fields", () => { const original = v.object({ a: v.string(), b: v.number(), c: v.boolean(), d: v.int64(), }); const omitted = original.omit("b", "d"); // Type checks assert< Equals< Infer<typeof omitted>, { a: string; c: boolean; } > >(); // Runtime checks expect(omitted.fields).toHaveProperty("a"); expect(omitted.fields).toHaveProperty("c"); expect(omitted.fields).not.toHaveProperty("b"); expect(omitted.fields).not.toHaveProperty("d"); }); test("preserves optional status", () => { const original = v.object({ a: v.string(), b: v.number(), }); const optional = original.asOptional(); const omitted = optional.omit("b"); // Runtime check: isOptional is preserved expect(omitted.isOptional).toBe("optional"); expect(omitted.fields).toHaveProperty("a"); expect(omitted.fields).not.toHaveProperty("b"); }); }); describe("pick", () => { test("picks specified fields from VObject", () => { const original = v.object({ a: v.string(), b: v.number(), c: v.boolean(), }); const picked = original.pick("a", "c"); // Type checks assert< Equals< Infer<typeof picked>, { a: string; c: boolean; } > >(); // Runtime checks expect(picked.fields).toHaveProperty("a"); expect(picked.fields).toHaveProperty("c"); expect(picked.fields).not.toHaveProperty("b"); expect(picked.isOptional).toBe("required"); }); test("picks single field", () => { const original = v.object({ a: v.string(), b: v.number(), c: v.boolean(), }); const picked = original.pick("b"); // Type checks assert< Equals< Infer<typeof picked>, { b: number; } > >(); // Runtime checks expect(picked.fields).toHaveProperty("b"); expect(picked.fields).not.toHaveProperty("a"); expect(picked.fields).not.toHaveProperty("c"); }); test("preserves optional status", () => { const original = v.object({ a: v.string(), b: v.number(), }); const optional = original.asOptional(); const picked = optional.pick("a"); // Runtime check: isOptional is preserved expect(picked.isOptional).toBe("optional"); expect(picked.fields).toHaveProperty("a"); expect(picked.fields).not.toHaveProperty("b"); }); }); describe("partial", () => { test("makes all fields optional", () => { const original = v.object({ a: v.string(), b: v.number(), c: v.boolean(), }); const partial = original.partial(); // Type checks assert< Equals< Infer<typeof partial>, { a?: string; b?: number; c?: boolean; } > >(); // Runtime checks expect(partial.fields.a.isOptional).toBe("optional"); expect(partial.fields.b.isOptional).toBe("optional"); expect(partial.fields.c.isOptional).toBe("optional"); expect(partial.isOptional).toBe("required"); }); test("works with already optional fields", () => { const original = v.object({ a: v.string(), b: v.optional(v.number()), c: v.boolean(), }); const partial = original.partial(); // Type checks - all fields should be optional type Result = Infer<typeof partial>; const _test1: Result = { a: "hello", b: 42, c: true }; const _test2: Result = { a: "hello" }; const _test3: Result = {}; // Runtime checks expect(partial.fields.a.isOptional).toBe("optional"); expect(partial.fields.b.isOptional).toBe("optional"); expect(partial.fields.c.isOptional).toBe("optional"); }); test("preserves optional status on VObject itself", () => { const original = v.object({ a: v.string(), b: v.number(), }); const optional = original.asOptional(); const partial = optional.partial(); // Runtime check: isOptional is preserved expect(partial.isOptional).toBe("optional"); expect(partial.fields.a.isOptional).toBe("optional"); expect(partial.fields.b.isOptional).toBe("optional"); }); }); describe("extend", () => { test("extends VObject with new fields", () => { const original = v.object({ a: v.string(), b: v.number(), }); const extended = original.extend({ c: v.boolean(), d: v.int64(), }); // Type checks type Result = Infer<typeof extended>; const _test: Result = { a: "hello", b: 42, c: true, d: 100n }; // Runtime checks expect(extended.fields).toHaveProperty("a"); expect(extended.fields).toHaveProperty("b"); expect(extended.fields).toHaveProperty("c"); expect(extended.fields).toHaveProperty("d"); expect(extended.isOptional).toBe("required"); }); test("extends with additional fields without conflicts", () => { const original = v.object({ a: v.string(), b: v.number(), }); const extended = original.extend({ c: v.int64(), d: v.boolean(), }); // Type checks type Result = Infer<typeof extended>; const _test: Result = { a: "hello", b: 42, c: 100n, d: true }; // Runtime checks expect(extended.fields.c.kind).toBe("int64"); expect(extended.fields.d.kind).toBe("boolean"); }); test("preserves optional status", () => { const original = v.object({ a: v.string(), }); const optional = original.asOptional(); const extended = optional.extend({ b: v.number(), }); // Runtime check: isOptional is preserved expect(extended.isOptional).toBe("optional"); expect(extended.fields).toHaveProperty("a"); expect(extended.fields).toHaveProperty("b"); }); }); describe("chaining utility methods", () => { test("can chain multiple operations", () => { const base = v.object({ a: v.string(), b: v.number(), c: v.boolean(), d: v.int64(), }); const result = base.omit("d").extend({ e: v.bytes() }).partial(); // Type checks type Result = Infer<typeof result>; const _test1: Result = { a: "hello", b: 42, c: true, e: new ArrayBuffer(0), }; const _test2: Result = { a: "hello" }; const _test3: Result = {}; // Runtime checks expect(result.fields).toHaveProperty("a"); expect(result.fields).toHaveProperty("b"); expect(result.fields).toHaveProperty("c"); expect(result.fields).toHaveProperty("e"); expect(result.fields).not.toHaveProperty("d"); expect(result.fields.a.isOptional).toBe("optional"); }); test("complex chaining scenario", () => { const user = v.object({ name: v.string(), email: v.string(), age: v.number(), password: v.string(), }); // Create a public user type: omit password, add system fields, then make partial for updates const publicUser = user.omit("password").extend({ _id: v.id("users"), _creationTime: v.number(), }); const userUpdate = publicUser.partial().omit("_id", "_creationTime"); // Type checks type PublicUser = Infer<typeof publicUser>; const _testPublic: PublicUser = { name: "Alice", email: "alice@example.com", age: 30, _id: "123" as GenericId<"users">, _creationTime: 1234567890, }; type UserUpdate = Infer<typeof userUpdate>; const _testUpdate1: UserUpdate = { name: "Alice", email: "alice@example.com", age: 30, }; const _testUpdate2: UserUpdate = { name: "Bob" }; const _testUpdate3: UserUpdate = {}; // Runtime checks expect(publicUser.fields).toHaveProperty("name"); expect(publicUser.fields).toHaveProperty("_id"); expect(publicUser.fields).not.toHaveProperty("password"); expect(userUpdate.fields).toHaveProperty("name"); expect(userUpdate.fields.name.isOptional).toBe("optional"); expect(userUpdate.fields).not.toHaveProperty("_id"); expect(userUpdate.fields).not.toHaveProperty("password"); }); }); describe("fieldPaths inference", () => { test("fieldPaths are correctly inferred after omit", () => { const original = v.object({ user: v.object({ name: v.string(), email: v.string(), }), count: v.number(), }); const _omitted = original.omit("count"); // The fieldPaths should include nested paths // TypeScript will infer this correctly from the Fields parameter type FieldPaths = (typeof _omitted)["fieldPaths"]; const _fieldPaths: FieldPaths = "user"; const _fieldPaths2: FieldPaths = "user.name"; const _fieldPaths3: FieldPaths = "user.email"; }); test("fieldPaths are correctly inferred after pick", () => { const original = v.object({ user: v.object({ name: v.string(), email: v.string(), }), count: v.number(), }); const _picked = original.pick("user"); // The fieldPaths should only include user paths type FieldPaths = (typeof _picked)["fieldPaths"]; const _fieldPaths: FieldPaths = "user"; const _fieldPaths2: FieldPaths = "user.name"; const _fieldPaths3: FieldPaths = "user.email"; }); test("fieldPaths are correctly inferred after extend", () => { const original = v.object({ a: v.string(), }); const _extended = original.extend({ b: v.object({ c: v.number(), }), }); // The fieldPaths should include both original and new paths type FieldPaths = (typeof _extended)["fieldPaths"]; const _fieldPaths: FieldPaths = "a"; const _fieldPaths2: FieldPaths = "b"; const _fieldPaths3: FieldPaths = "b.c"; }); }); });