@peers-app/peers-sdk 0.16.4 → 0.16.6

package/dist/contracts/__tests__/validate.test.js

@@ -0,0 +1,699 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+const types_1 = require("../types");
+const validate_1 = require("../validate");
+const DEFAULT_CONTRACT_ID = (0, utils_1.newid)();
+/** Helper to build a minimal contract definition for tests. */
+function makeContract(overrides = {}) {
+    return {
+        contractId: DEFAULT_CONTRACT_ID,
+        version: 1,
+        name: "Test Contract",
+        description: "A test contract",
+        tables: [],
+        tools: [],
+        observables: [],
+        ...overrides,
+    };
+}
+describe("validateProviderSatisfiesContract", () => {
+    describe("tables", () => {
+        it("passes when implementation has the same fields as the contract", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "title", type: field_type_1.FieldType.string },
+                        ],
+                    },
+                ],
+            });
+            const impl = makeContract({ tables: [...contract.tables] });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it("passes when implementation has extra optional fields", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "title", type: field_type_1.FieldType.string },
+                        ],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "title", type: field_type_1.FieldType.string },
+                            { name: "priority", type: field_type_1.FieldType.number, optional: true },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(true);
+        });
+        it("fails when implementation is missing a required field", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "title", type: field_type_1.FieldType.string },
+                            { name: "status", type: field_type_1.FieldType.string },
+                        ],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "title", type: field_type_1.FieldType.string },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].message).toContain("status");
+            expect(result.errors[0].message).toContain("missing");
+        });
+        it("allows missing optional contract fields in the implementation", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "notes", type: field_type_1.FieldType.string, optional: true },
+                        ],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(true);
+        });
+        it("fails when a field has the wrong type", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "count", type: field_type_1.FieldType.number },
+                        ],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "Tasks table",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "count", type: field_type_1.FieldType.string },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].message).toContain("type mismatch");
+        });
+        it("fails when contract requires required but implementation has optional", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "d",
+                        primaryKeyName: "taskId",
+                        fields: [{ name: "title", type: field_type_1.FieldType.string }],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "d",
+                        primaryKeyName: "taskId",
+                        fields: [{ name: "title", type: field_type_1.FieldType.string, optional: true }],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].message).toContain("optional");
+        });
+        it("fails when contract table is entirely missing from implementation", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "d",
+                        primaryKeyName: "taskId",
+                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const impl = makeContract({ tables: [] });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].kind).toBe("table");
+            expect(result.errors[0].message).toContain("not provided");
+        });
+        it("fails when primary key names differ", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "d",
+                        primaryKeyName: "taskId",
+                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "d",
+                        primaryKeyName: "id",
+                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].message).toContain("primary key");
+        });
+        it("fails when implementation has extra required fields not in contract", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "d",
+                        primaryKeyName: "taskId",
+                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tables: [
+                    {
+                        name: "Tasks",
+                        description: "d",
+                        primaryKeyName: "taskId",
+                        fields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "internalField", type: field_type_1.FieldType.string },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].message).toContain("extra required field");
+        });
+        it("validates isArray compatibility", () => {
+            const contract = makeContract({
+                tables: [
+                    {
+                        name: "T",
+                        description: "d",
+                        primaryKeyName: "id",
+                        fields: [
+                            { name: "id", type: field_type_1.FieldType.id },
+                            { name: "tags", type: field_type_1.FieldType.string, isArray: true },
+                        ],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tables: [
+                    {
+                        name: "T",
+                        description: "d",
+                        primaryKeyName: "id",
+                        fields: [
+                            { name: "id", type: field_type_1.FieldType.id },
+                            { name: "tags", type: field_type_1.FieldType.string },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].message).toContain("array");
+        });
+    });
+    describe("tools", () => {
+        it("passes when tool signatures match", () => {
+            const contract = makeContract({
+                tools: [
+                    {
+                        name: "create-task",
+                        usageDescription: "Creates a task",
+                        inputFields: [{ name: "title", type: field_type_1.FieldType.string }],
+                        outputFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const impl = makeContract({ tools: [...contract.tools] });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(true);
+        });
+        it("fails when a required tool is missing", () => {
+            const contract = makeContract({
+                tools: [
+                    {
+                        name: "create-task",
+                        usageDescription: "Creates a task",
+                        inputFields: [],
+                        outputFields: [],
+                    },
+                ],
+            });
+            const impl = makeContract({ tools: [] });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].kind).toBe("tool");
+        });
+        it("allows extra optional input fields in implementation", () => {
+            const contract = makeContract({
+                tools: [
+                    {
+                        name: "create-task",
+                        usageDescription: "d",
+                        inputFields: [{ name: "title", type: field_type_1.FieldType.string }],
+                        outputFields: [],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tools: [
+                    {
+                        name: "create-task",
+                        usageDescription: "d",
+                        inputFields: [
+                            { name: "title", type: field_type_1.FieldType.string },
+                            { name: "priority", type: field_type_1.FieldType.number, optional: true },
+                        ],
+                        outputFields: [],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(true);
+        });
+        it("fails when implementation has extra required input fields", () => {
+            const contract = makeContract({
+                tools: [
+                    {
+                        name: "create-task",
+                        usageDescription: "d",
+                        inputFields: [{ name: "title", type: field_type_1.FieldType.string }],
+                        outputFields: [],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tools: [
+                    {
+                        name: "create-task",
+                        usageDescription: "d",
+                        inputFields: [
+                            { name: "title", type: field_type_1.FieldType.string },
+                            { name: "mandatory", type: field_type_1.FieldType.string },
+                        ],
+                        outputFields: [],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].message).toContain("extra required input");
+        });
+        it("allows extra output fields in implementation (returns more data)", () => {
+            const contract = makeContract({
+                tools: [
+                    {
+                        name: "create-task",
+                        usageDescription: "d",
+                        inputFields: [],
+                        outputFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                tools: [
+                    {
+                        name: "create-task",
+                        usageDescription: "d",
+                        inputFields: [],
+                        outputFields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "createdAt", type: field_type_1.FieldType.Date },
+                        ],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(true);
+        });
+    });
+    describe("observables", () => {
+        it("passes when observables match", () => {
+            const contract = makeContract({
+                observables: [
+                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: false },
+                ],
+            });
+            const impl = makeContract({ observables: [...contract.observables] });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(true);
+        });
+        it("fails when an observable is missing", () => {
+            const contract = makeContract({
+                observables: [
+                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: false },
+                ],
+            });
+            const impl = makeContract({ observables: [] });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].kind).toBe("observable");
+        });
+        it("fails on value type mismatch", () => {
+            const contract = makeContract({
+                observables: [
+                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: false },
+                ],
+            });
+            const impl = makeContract({
+                observables: [
+                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.string, writable: false },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].message).toContain("type mismatch");
+        });
+        it("fails when contract requires writable but impl is read-only", () => {
+            const contract = makeContract({
+                observables: [
+                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: true },
+                ],
+            });
+            const impl = makeContract({
+                observables: [
+                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: false },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0].message).toContain("writable");
+        });
+    });
+});
+describe("validateImmutability", () => {
+    it("allows any change for dev contracts", () => {
+        const existing = makeContract({ devTag: "dev", tables: [] });
+        const incoming = makeContract({
+            devTag: "dev",
+            tables: [
+                {
+                    name: "New",
+                    description: "d",
+                    primaryKeyName: "id",
+                    fields: [{ name: "id", type: field_type_1.FieldType.id }],
+                },
+            ],
+        });
+        const result = (0, validate_1.validateImmutability)(existing, incoming);
+        expect(result.valid).toBe(true);
+    });
+    it("rejects registering a dev version when stable version already exists", () => {
+        const existing = makeContract({
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        });
+        const incoming = makeContract({
+            devTag: "dev",
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        });
+        const result = (0, validate_1.validateImmutability)(existing, incoming);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0].message).toContain("frozen");
+    });
+    it("passes when a frozen contract is re-published identically", () => {
+        const contract = makeContract({
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        });
+        const result = (0, validate_1.validateImmutability)(contract, { ...contract });
+        expect(result.valid).toBe(true);
+    });
+    it("fails when a frozen contract shape is modified", () => {
+        const existing = makeContract({
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        });
+        const incoming = makeContract({
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [
+                        { name: "taskId", type: field_type_1.FieldType.id },
+                        { name: "title", type: field_type_1.FieldType.string },
+                    ],
+                },
+            ],
+        });
+        const result = (0, validate_1.validateImmutability)(existing, incoming);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0].message).toContain("frozen");
+    });
+});
+describe("validateAlsoImplements", () => {
+    const contractStore = new Map();
+    const TASKS_CONTRACT_ID = (0, utils_1.newid)();
+    const FANCY_TASKS_CONTRACT_ID = (0, utils_1.newid)();
+    const NONEXISTENT_ID = (0, utils_1.newid)();
+    function getContract(id, ver) {
+        return contractStore.get((0, types_1.contractKey)(id, ver));
+    }
+    beforeEach(() => {
+        contractStore.clear();
+    });
+    it("passes when implementation is a superset of the target contract", () => {
+        const targetV1 = makeContract({
+            contractId: TASKS_CONTRACT_ID,
+            version: 1,
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [
+                        { name: "taskId", type: field_type_1.FieldType.id },
+                        { name: "title", type: field_type_1.FieldType.string },
+                    ],
+                },
+            ],
+        });
+        contractStore.set((0, types_1.contractKey)(TASKS_CONTRACT_ID, 1), targetV1);
+        const impl = makeContract({
+            contractId: FANCY_TASKS_CONTRACT_ID,
+            version: 1,
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [
+                        { name: "taskId", type: field_type_1.FieldType.id },
+                        { name: "title", type: field_type_1.FieldType.string },
+                        { name: "priority", type: field_type_1.FieldType.number, optional: true },
+                    ],
+                },
+            ],
+        });
+        const result = (0, validate_1.validateAlsoImplements)(impl, [{ contractId: TASKS_CONTRACT_ID, version: 1 }], getContract);
+        expect(result.valid).toBe(true);
+    });
+    it("validates all versions in a range", () => {
+        const v1 = makeContract({
+            contractId: TASKS_CONTRACT_ID,
+            version: 1,
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [
+                        { name: "taskId", type: field_type_1.FieldType.id },
+                        { name: "title", type: field_type_1.FieldType.string },
+                    ],
+                },
+            ],
+        });
+        const v2 = makeContract({
+            contractId: TASKS_CONTRACT_ID,
+            version: 2,
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [
+                        { name: "taskId", type: field_type_1.FieldType.id },
+                        { name: "title", type: field_type_1.FieldType.string },
+                        { name: "status", type: field_type_1.FieldType.string, optional: true },
+                    ],
+                },
+            ],
+        });
+        contractStore.set((0, types_1.contractKey)(TASKS_CONTRACT_ID, 1), v1);
+        contractStore.set((0, types_1.contractKey)(TASKS_CONTRACT_ID, 2), v2);
+        // Implementation satisfies both: has all fields from both versions.
+        // 'status' is optional so v1 consumers can still write valid rows.
+        const impl = makeContract({
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [
+                        { name: "taskId", type: field_type_1.FieldType.id },
+                        { name: "title", type: field_type_1.FieldType.string },
+                        { name: "status", type: field_type_1.FieldType.string, optional: true },
+                    ],
+                },
+            ],
+        });
+        const result = (0, validate_1.validateAlsoImplements)(impl, [{ contractId: TASKS_CONTRACT_ID, version: { from: 1, to: 2 } }], getContract);
+        expect(result.valid).toBe(true);
+    });
+    it("fails when implementation is missing a field from one version in range", () => {
+        const v1 = makeContract({
+            contractId: TASKS_CONTRACT_ID,
+            version: 1,
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        });
+        const v2 = makeContract({
+            contractId: TASKS_CONTRACT_ID,
+            version: 2,
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [
+                        { name: "taskId", type: field_type_1.FieldType.id },
+                        { name: "assignee", type: field_type_1.FieldType.string },
+                    ],
+                },
+            ],
+        });
+        contractStore.set((0, types_1.contractKey)(TASKS_CONTRACT_ID, 1), v1);
+        contractStore.set((0, types_1.contractKey)(TASKS_CONTRACT_ID, 2), v2);
+        // Implementation only satisfies v1 (missing 'assignee')
+        const impl = makeContract({
+            tables: [
+                {
+                    name: "Tasks",
+                    description: "d",
+                    primaryKeyName: "taskId",
+                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        });
+        const result = (0, validate_1.validateAlsoImplements)(impl, [{ contractId: TASKS_CONTRACT_ID, version: { from: 1, to: 2 } }], getContract);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0].message).toContain("v2");
+        expect(result.errors[0].message).toContain("assignee");
+    });
+    it("fails when a referenced contract does not exist", () => {
+        const impl = makeContract({ tables: [] });
+        const result = (0, validate_1.validateAlsoImplements)(impl, [{ contractId: NONEXISTENT_ID, version: 1 }], getContract);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0].message).toContain("not found");
+    });
+});