@peers-app/peers-sdk 0.27.3 → 0.27.5

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

@@ -1,669 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const types_1 = require("../../data/orm/types");
-const field_type_1 = require("../../types/field-type");
-const utils_1 = require("../../utils");
-const builder_1 = require("../builder");
-const extract_1 = require("../extract");
-const types_2 = require("../types");
-beforeAll(() => {
-    (0, extract_1.setSchemaToFieldsFn)(types_1.schemaToFields);
-});
-const TEST_PKG_ID = (0, utils_1.newid)();
-const TASKS_ID = (0, utils_1.newid)();
-const NOTES_ID = (0, utils_1.newid)();
-const AUTH_ID = (0, utils_1.newid)();
-const PROJECTS_ID = (0, utils_1.newid)();
-const FANCY_TASKS_ID = (0, utils_1.newid)();
-const GENERIC_ID = (0, utils_1.newid)();
-describe("definePackage", () => {
-    it("carries a contract's description, or an empty one", () => {
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.contract(TASKS_ID, 1, "Tasks", "Your tasks, by status.");
-            pkg.contract(NOTES_ID, 1, "Notes");
-        });
-        expect(result.contracts.map(({ name, description }) => [name, description])).toEqual([
-            ["Tasks", "Your tasks, by status."],
-            ["Notes", ""],
-        ]);
-    });
-    it("produces a contract definition from a single contract with tables and tools", () => {
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const tasks = pkg.contract(TASKS_ID, 1, "Tasks");
-            tasks.tables = [
-                {
-                    metaData: {
-                        name: "Tasks",
-                        description: "Task tracking",
-                        primaryKeyName: "taskId",
-                        fields: [],
-                    },
-                    schema: zod_1.z.object({
-                        taskId: zod_1.z.string().describe("PK"),
-                        title: zod_1.z.string().describe("Title"),
-                    }),
-                },
-            ];
-            tasks.tools = [
-                {
-                    tool: {
-                        name: "create-task",
-                        usageDescription: "Creates a task",
-                        inputSchema: {
-                            fields: [{ name: "title", type: field_type_1.FieldType.string, description: "Title" }],
-                        },
-                        outputSchema: {
-                            fields: [{ name: "taskId", type: field_type_1.FieldType.id, description: "ID" }],
-                        },
-                    },
-                },
-            ];
-        });
-        expect(result.contracts).toHaveLength(1);
-        const contract = result.contracts[0];
-        expect(contract.contractId).toBe(TASKS_ID);
-        expect(contract.version).toBe(1);
-        expect(contract.name).toBe("Tasks");
-        expect(contract.description).toBe("");
-        expect(contract.devTag).toBe("dev");
-        expect(contract.tables).toHaveLength(1);
-        expect(contract.tables[0].name).toBe("Tasks");
-        expect(contract.tables[0].fields).toHaveLength(2);
-        expect(contract.tools).toHaveLength(1);
-        expect(contract.tools[0].name).toBe("create-task");
-        expect(contract.tools[0].inputFields).toHaveLength(1);
-        expect(contract.tools[0].outputFields).toHaveLength(1);
-    });
-    it("supports multiple contracts from one package", () => {
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const tasks = pkg.contract(TASKS_ID, 1, "Tasks");
-            tasks.tables = [
-                {
-                    metaData: {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-            const notes = pkg.contract(NOTES_ID, 1, "Notes");
-            notes.tables = [
-                {
-                    metaData: {
-                        name: "Notes",
-                        description: "d",
-                        primaryKeyName: "noteId",
-                        fields: [{ name: "noteId", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-        });
-        expect(result.contracts).toHaveLength(2);
-        expect(result.contracts[0].contractId).toBe(TASKS_ID);
-        expect(result.contracts[1].contractId).toBe(NOTES_ID);
-    });
-    it("records consumed contracts", () => {
-        let tasksHandle;
-        let authHandle;
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            tasksHandle = pkg.consumes(TASKS_ID, 1);
-            authHandle = pkg.consumes(AUTH_ID, 2);
-            const projects = pkg.contract(PROJECTS_ID, 1, "Projects");
-            projects.tables = [
-                {
-                    metaData: {
-                        name: "Projects",
-                        description: "d",
-                        primaryKeyName: "projectId",
-                        fields: [{ name: "projectId", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-        });
-        expect(result.consumes).toHaveLength(2);
-        expect(result.consumes[0].contractId).toBe(TASKS_ID);
-        expect(result.consumes[0].version).toBe(1);
-        expect(result.consumes[0].handle).toBe(tasksHandle);
-        expect(result.consumes[1].contractId).toBe(AUTH_ID);
-        expect(result.consumes[1].version).toBe(2);
-        expect(result.consumes[1].handle).toBe(authHandle);
-    });
-    it("records remote contracts as deferred handles without requiring a consume", () => {
-        let remoteHandle;
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            // A package may target its own contract on other devices.
-            const projects = pkg.contract(PROJECTS_ID, 1, "Projects");
-            projects.tools = [];
-            remoteHandle = pkg.remote(PROJECTS_ID, 1);
-        });
-        expect(result.consumes).toHaveLength(0);
-        expect(result.remotes).toHaveLength(1);
-        expect(result.remotes?.[0]).toMatchObject({ contractId: PROJECTS_ID, version: 1 });
-        expect(result.remotes?.[0].handle).toBe(remoteHandle);
-        expect(remoteHandle?.consumer).toBeInstanceOf(Promise);
-    });
-    it("validates remote declarations", () => {
-        expect(() => (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.remote("not-an-id", 1);
-        })).toThrow("remote contractId must be a valid peer ID");
-        expect(() => (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.remote(TASKS_ID, 0);
-        })).toThrow("remote version must be a positive integer");
-    });
-    it("preserves consume options and returns a deferred handle", () => {
-        const preferredProviderId = (0, utils_1.newid)();
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.consumes(TASKS_ID, 1, {
-                providerPackageIds: [preferredProviderId],
-                fallbackToDefaultProvider: true,
-            });
-            pkg.consumes(AUTH_ID, 2, {
-                optional: true,
-                providerPackageIds: [preferredProviderId],
-                fallbackToDefaultProvider: false,
-            });
-        });
-        const [required, optional] = result.consumes;
-        expect(required).toMatchObject({
-            contractId: TASKS_ID,
-            version: 1,
-            providerPackageIds: [preferredProviderId],
-            fallbackToDefaultProvider: true,
-        });
-        expect(required.optional).toBeUndefined();
-        expect(required.handle).toBeDefined();
-        expect(typeof required.handle?.consumer.then).toBe("function");
-        // Handle itself must not be thenable (naive await on the return value must not wait).
-        expect(required.handle.then).toBeUndefined();
-        expect(optional).toMatchObject({
-            contractId: AUTH_ID,
-            version: 2,
-            optional: true,
-            providerPackageIds: [preferredProviderId],
-            fallbackToDefaultProvider: false,
-        });
-        expect(optional.handle).toBeDefined();
-    });
-    it("accepts a type argument that narrows the resolved consumer", () => {
-        (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const required = pkg.consumes(TASKS_ID, 1);
-            const optional = pkg.consumes(AUTH_ID, 1, { optional: true });
-            // Compile-time checks: required → TypedConsumer; optional → TypedConsumer | undefined.
-            void (async () => {
-                const requiredConsumer = await required.consumer;
-                const optionalConsumer = await optional.consumer;
-                void requiredConsumer;
-                void optionalConsumer;
-                // Named table methods (not only dataChanged) must be present on ITableProxy.
-                const _list = requiredConsumer.tables.ConsoleLogs.list;
-                const _deleteOldLogs = requiredConsumer.tables.ConsoleLogs.deleteOldLogs;
-                void _list;
-                void _deleteOldLogs;
-                // Typed consumers may omit empty bags — these must not exist on TypedConsumer.
-                // @ts-expect-error no tools bag on slim typed consumer
-                void requiredConsumer.tools;
-                // @ts-expect-error no events bag on slim typed consumer
-                void requiredConsumer.events;
-                // @ts-expect-error no observables bag on slim typed consumer
-                void requiredConsumer.observables;
-                // @ts-expect-error optional consume must allow undefined
-                const tooNarrow = await optional.consumer;
-                void tooNarrow;
-            })();
-        });
-    });
-    it("ILogsConsumer exposes ConsoleLogs as ITableProxy without empty bags", () => {
-        (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const handle = pkg.consumes(TASKS_ID, 1, { optional: true });
-            void (async () => {
-                const logs = await handle.consumer;
-                if (!logs)
-                    return;
-                const _list = logs.tables.ConsoleLogs.list;
-                const _deleteOldLogs = logs.tables.ConsoleLogs.deleteOldLogs;
-                void _list;
-                void _deleteOldLogs;
-                // @ts-expect-error ILogsConsumer has no tools bag
-                void logs.tools;
-                // @ts-expect-error ILogsConsumer has no events bag
-                void logs.events;
-                // @ts-expect-error ILogsConsumer has no observables bag
-                void logs.observables;
-            })();
-        });
-    });
-    it("settles required handles with a consumer and optional handles with undefined", async () => {
-        const { settleConsumedContractHandle, rejectConsumedContractHandle } = await Promise.resolve().then(() => require("../builder"));
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.consumes(TASKS_ID, 1);
-            pkg.consumes(AUTH_ID, 1, { optional: true });
-        });
-        const requiredHandle = result.consumes[0].handle;
-        const optionalHandle = result.consumes[1].handle;
-        expect(requiredHandle).toBeDefined();
-        expect(optionalHandle).toBeDefined();
-        if (!requiredHandle || !optionalHandle) {
-            throw new Error("expected consumes handles");
-        }
-        const fakeConsumer = {
-            contractId: TASKS_ID,
-            version: 1,
-            tables: {},
-            tools: {},
-            observables: {},
-            events: {},
-            loadingPromise: Promise.resolve(),
-            dispose: () => { },
-        };
-        settleConsumedContractHandle(requiredHandle, fakeConsumer);
-        settleConsumedContractHandle(optionalHandle, undefined);
-        await expect(requiredHandle.consumer).resolves.toBe(fakeConsumer);
-        await expect(optionalHandle.consumer).resolves.toBeUndefined();
-        expect(() => settleConsumedContractHandle(requiredHandle, fakeConsumer)).toThrow("already been settled");
-        expect(() => rejectConsumedContractHandle(optionalHandle, new Error("late"))).toThrow("already been settled");
-    });
-    it("rejects a required consume handle once", async () => {
-        const { rejectConsumedContractHandle } = await Promise.resolve().then(() => require("../builder"));
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.consumes(TASKS_ID, 1);
-        });
-        const requiredHandle = result.consumes[0].handle;
-        expect(requiredHandle).toBeDefined();
-        if (!requiredHandle) {
-            throw new Error("expected consumes handle");
-        }
-        const err = new Error("No provider for Tasks");
-        rejectConsumedContractHandle(requiredHandle, err);
-        await expect(requiredHandle.consumer).rejects.toThrow("No provider for Tasks");
-        expect(() => rejectConsumedContractHandle(requiredHandle, err)).toThrow("already been settled");
-    });
-    it("throws when consumes providerPackageIds contains an invalid peer ID", () => {
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                pkg.consumes(TASKS_ID, 1, { providerPackageIds: ["not-valid"] });
-            });
-        }).toThrow("providerPackageIds");
-    });
-    it("throws when consumes version is not a positive integer", () => {
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                pkg.consumes(TASKS_ID, 0);
-            });
-        }).toThrow("positive integer");
-    });
-    it("records alsoImplements declarations", () => {
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const fancy = pkg.contract(FANCY_TASKS_ID, 1, "Fancy Tasks");
-            fancy.alsoImplements(TASKS_ID, 1);
-            fancy.alsoImplements(TASKS_ID, { from: 1, to: 3 });
-            fancy.tables = [
-                {
-                    metaData: {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-        });
-        const key = (0, types_2.contractKey)(FANCY_TASKS_ID, 1);
-        expect(result.alsoImplements.has(key)).toBe(true);
-        const decls = result.alsoImplements.get(key) ?? [];
-        expect(decls).toHaveLength(2);
-        expect(decls[0]).toEqual({ contractId: TASKS_ID, version: 1 });
-        expect(decls[1]).toEqual({ contractId: TASKS_ID, version: { from: 1, to: 3 } });
-    });
-    it("records the contracts a hub implementation exposes", () => {
-        const hubId = (0, utils_1.newid)();
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.contract(GENERIC_ID, 1, "Generic");
-            const hub = pkg.contract(hubId, 2, "Hub");
-            hub.exposes(GENERIC_ID, 1);
-        });
-        expect(result.exposes?.get((0, types_2.contractKey)(hubId, 2))).toEqual([
-            { contractId: GENERIC_ID, version: 1 },
-        ]);
-        expect(result.exposes?.has((0, types_2.contractKey)(GENERIC_ID, 1))).toBe(false);
-        expect(result.contracts.find((contract) => contract.contractId === hubId)).not.toHaveProperty("exposes");
-        const hub = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const contract = pkg.contract(hubId, 2, "Hub");
-            expect(() => contract.exposes("short", 1)).toThrow("valid peer ID");
-            expect(() => contract.exposes(GENERIC_ID, 0)).toThrow("positive integer");
-        });
-        expect(hub.exposes?.size).toBe(0);
-    });
-    it("rejects invalid legacy exposures before installation", () => {
-        const hubId = (0, utils_1.newid)();
-        const build = (targets) => (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.contract(GENERIC_ID, 1, "Generic");
-            const hub = pkg.contract(hubId, 1, "Hub");
-            for (const target of targets)
-                hub.exposes(target, 1);
-        });
-        expect(() => build([(0, utils_1.newid)()])).toThrow("doesn't provide");
-        expect(() => build([hubId])).toThrow("can't expose itself");
-        expect(() => build([GENERIC_ID, GENERIC_ID])).toThrow("twice");
-    });
-    it("includes package-level assistants and appNavs", () => {
-        const assistant = { id: "asst1", name: "Task Bot" };
-        const nav = { name: "Tasks", iconClassName: "bi bi-list-task", navigationPath: "app" };
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.assistants = [assistant];
-            pkg.appNavs = [nav];
-            const c = pkg.contract(GENERIC_ID, 1, "Generic");
-            c.tables = [
-                {
-                    metaData: {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-        });
-        expect(result.assistants).toEqual([assistant]);
-        expect(result.appNavs).toEqual([nav]);
-    });
-    it("always assigns devTag 'dev' to contracts from definePackage", () => {
-        const devContractId = (0, utils_1.newid)();
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const c = pkg.contract(devContractId, 1, "Dev Contract");
-            c.tables = [
-                {
-                    metaData: {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-        });
-        expect(result.contracts[0].devTag).toBe("dev");
-    });
-    it("supports observables on contracts", () => {
-        const obsContractId = (0, utils_1.newid)();
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const c = pkg.contract(obsContractId, 1, "Observable Contract");
-            c.tables = [
-                {
-                    metaData: {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-            c.observables = [
-                {
-                    name: "taskCount",
-                    description: "Count of tasks",
-                    valueType: field_type_1.FieldType.number,
-                    writable: false,
-                },
-            ];
-        });
-        expect(result.contracts[0].observables).toHaveLength(1);
-        expect(result.contracts[0].observables[0].name).toBe("taskCount");
-    });
-    it("emits contract events without sharing or mutating the caller's array", () => {
-        const eventContractId = (0, utils_1.newid)();
-        const events = [
-            {
-                name: "taskChanged",
-                description: "A task changed",
-                payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-            },
-        ];
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const contract = pkg.contract(eventContractId, 1, "Event Contract");
-            contract.events = events;
-        });
-        const emittedEvents = result.contracts[0].events;
-        expect(emittedEvents).toEqual(events);
-        expect(emittedEvents).not.toBe(events);
-        emittedEvents?.push({
-            name: "otherEvent",
-            description: "Another event",
-            payloadFields: [],
-        });
-        expect(events).toHaveLength(1);
-    });
-    it("uses provided name and description on the contract definition", () => {
-        const cid = (0, utils_1.newid)();
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const c = pkg.contract(cid, 1, "Human-Readable Name");
-            c.tables = [
-                {
-                    metaData: {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-        });
-        expect(result.contracts[0].name).toBe("Human-Readable Name");
-        expect(result.contracts[0].description).toBe("");
-    });
-    it("includes packageId and version in the result", () => {
-        const cid = (0, utils_1.newid)();
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.version = "1.2.3";
-            const c = pkg.contract(cid, 1, "C");
-            c.tables = [
-                {
-                    metaData: {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-        });
-        expect(result.packageId).toBe(TEST_PKG_ID);
-        expect(result.version).toBe("1.2.3");
-    });
-    it("leaves version undefined when not set", () => {
-        const cid = (0, utils_1.newid)();
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            const c = pkg.contract(cid, 1, "C");
-            c.tables = [
-                {
-                    metaData: {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                },
-            ];
-        });
-        expect(result.packageId).toBe(TEST_PKG_ID);
-        expect(result.version).toBeUndefined();
-    });
-});
-describe("definePackage — error cases", () => {
-    it("throws when packageId is not set", () => {
-        const cid = (0, utils_1.newid)();
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.contract(cid, 1, "C");
-            });
-        }).toThrow("must set packageId");
-    });
-    it("throws when packageId is not a valid peer ID", () => {
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = "not-valid";
-            });
-        }).toThrow("valid peer ID");
-    });
-    it("allows package with no contracts (UI-only)", () => {
-        const nav = { name: "Game", iconClassName: "bi-controller", navigationPath: "play" };
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.appNavs = [nav];
-        });
-        expect(result.contracts).toHaveLength(0);
-        expect(result.consumes).toHaveLength(0);
-        expect(result.tableDefinitions).toHaveLength(0);
-        expect(result.appNavs).toEqual([nav]);
-    });
-    it("allows consumes-only package with no defined contracts", () => {
-        const result = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = TEST_PKG_ID;
-            pkg.consumes(TASKS_ID, 1);
-        });
-        expect(result.contracts).toHaveLength(0);
-        expect(result.consumes).toHaveLength(1);
-        expect(result.tableDefinitions).toHaveLength(0);
-    });
-    it("throws on duplicate contract ID + version", () => {
-        const dupId = (0, utils_1.newid)();
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                pkg.contract(dupId, 1, "First");
-                pkg.contract(dupId, 1, "Second");
-            });
-        }).toThrow("Duplicate contract");
-    });
-    it("allows same contractId with different versions", () => {
-        const cid = (0, utils_1.newid)();
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                const v1 = pkg.contract(cid, 1, "V1");
-                v1.tables = [
-                    {
-                        metaData: {
-                            name: "T",
-                            description: "d",
-                            primaryKeyName: "id",
-                            fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                        },
-                    },
-                ];
-                const v2 = pkg.contract(cid, 2, "V2");
-                v2.tables = [
-                    {
-                        metaData: {
-                            name: "T",
-                            description: "d",
-                            primaryKeyName: "id",
-                            fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                        },
-                    },
-                ];
-            });
-        }).not.toThrow();
-    });
-    it("throws on non-integer version", () => {
-        const cid = (0, utils_1.newid)();
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                pkg.contract(cid, 1.5, "Bad Version");
-            });
-        }).toThrow("positive integer");
-    });
-    it("throws on zero version", () => {
-        const cid = (0, utils_1.newid)();
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                pkg.contract(cid, 0, "Zero");
-            });
-        }).toThrow("positive integer");
-    });
-    it("throws on negative version", () => {
-        const cid = (0, utils_1.newid)();
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                pkg.contract(cid, -1, "Negative");
-            });
-        }).toThrow("positive integer");
-    });
-    it("throws when contractId is not a valid peer ID", () => {
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                pkg.contract("tasks001", 1, "Bad ID");
-            });
-        }).toThrow("valid peer ID");
-    });
-    it("throws when consumes contractId is not a valid peer ID", () => {
-        const cid = (0, utils_1.newid)();
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                pkg.consumes("not-a-peer-id", 1);
-                const c = pkg.contract(cid, 1, "C");
-                c.tables = [
-                    {
-                        metaData: {
-                            name: "T",
-                            description: "d",
-                            primaryKeyName: "id",
-                            fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                        },
-                    },
-                ];
-            });
-        }).toThrow("valid peer ID");
-    });
-    it("throws when alsoImplements targetContractId is not a valid peer ID", () => {
-        const cid = (0, utils_1.newid)();
-        expect(() => {
-            (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = TEST_PKG_ID;
-                const c = pkg.contract(cid, 1, "C");
-                c.alsoImplements("invalid-id", 1);
-                c.tables = [
-                    {
-                        metaData: {
-                            name: "T",
-                            description: "d",
-                            primaryKeyName: "id",
-                            fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                        },
-                    },
-                ];
-            });
-        }).toThrow("valid peer ID");
-    });
-});

package/dist/contracts/__tests__/contract-events.test.d.ts

@@ -1 +0,0 @@
-export {};