@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/data/orm/table-container-events.test.d.ts

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

package/dist/data/orm/table-container-events.test.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const field_type_1 = require("../../types/field-type");
-const client_proxy_data_source_1 = require("./client-proxy.data-source");
-const event_registry_1 = require("./event-registry");
-const table_container_1 = require("./table-container");
-describe("TableFactory Event Sharing", () => {
-    const testSchema = zod_1.z.object({
-        id: zod_1.z.string(),
-        name: zod_1.z.string(),
-    });
-    const testMetaData = {
-        name: "TestTable",
-        description: "Test table for event sharing",
-        primaryKeyName: "id",
-        fields: [
-            { name: "id", type: field_type_1.FieldType.string, optional: false },
-            { name: "name", type: field_type_1.FieldType.string, optional: false },
-        ],
-    };
-    it("should share event emitters when using the same EventRegistry", () => {
-        // Create mock data context for event registry
-        const mockDataContext = {
-            dataContextId: "test-context",
-        };
-        // Create shared event registry
-        const sharedRegistry = new event_registry_1.EventRegistry(mockDataContext);
-        // Create table factory function that uses shared registry
-        const tableFactory1 = jest
-            .fn()
-            .mockImplementation((metaData, schema, TableClass) => {
-            const deps = {
-                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, "test-context"),
-                eventRegistry: sharedRegistry,
-            };
-            return new (TableClass || require("./table").Table)(metaData, deps);
-        });
-        const tableFactory2 = jest
-            .fn()
-            .mockImplementation((metaData, schema, TableClass) => {
-            const deps = {
-                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, "test-context"),
-                eventRegistry: sharedRegistry,
-            };
-            return new (TableClass || require("./table").Table)(metaData, deps);
-        });
-        // Create two table containers with the same shared registry
-        const container1 = new table_container_1.TableContainer(tableFactory1);
-        const container2 = new table_container_1.TableContainer(tableFactory2);
-        // Create tables from both factories
-        const table1 = container1.getTable(testMetaData, testSchema);
-        const table2 = container2.getTable(testMetaData, testSchema);
-        // Verify they use the same event emitter
-        expect(table1.dataChangedEmitter).toBe(table2.dataChangedEmitter);
-        // Verify they have the same dataChanged event
-        expect(table1.dataChanged).toBe(table2.dataChanged);
-        // Verify the shared registry only has one emitter for this table
-        expect(sharedRegistry.getEmitterCount()).toBe(1);
-    });
-    it("should have separate event emitters when using different EventRegistry instances", () => {
-        // Create separate mock data contexts for event registries
-        const mockContext1 = { dataContextId: "test-context-1" };
-        const mockContext2 = { dataContextId: "test-context-2" };
-        // Create separate event registries
-        const registry1 = new event_registry_1.EventRegistry(mockContext1);
-        const registry2 = new event_registry_1.EventRegistry(mockContext2);
-        // Create table factory functions with different registries
-        const tableFactory1 = jest
-            .fn()
-            .mockImplementation((metaData, schema, TableClass) => {
-            const deps = {
-                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, "test-context"),
-                eventRegistry: registry1,
-            };
-            return new (TableClass || require("./table").Table)(metaData, deps);
-        });
-        const tableFactory2 = jest
-            .fn()
-            .mockImplementation((metaData, schema, TableClass) => {
-            const deps = {
-                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, "test-context"),
-                eventRegistry: registry2,
-            };
-            return new (TableClass || require("./table").Table)(metaData, deps);
-        });
-        // Create two table containers with different registries
-        const container1 = new table_container_1.TableContainer(tableFactory1);
-        const container2 = new table_container_1.TableContainer(tableFactory2);
-        // Create tables from both factories
-        const table1 = container1.getTable(testMetaData, testSchema);
-        const table2 = container2.getTable(testMetaData, testSchema);
-        // Verify they use different event emitters
-        expect(table1.dataChangedEmitter).not.toBe(table2.dataChangedEmitter);
-        // Verify they have different dataChanged events
-        expect(table1.dataChanged).not.toBe(table2.dataChanged);
-        // Verify each registry has one emitter
-        expect(registry1.getEmitterCount()).toBe(1);
-        expect(registry2.getEmitterCount()).toBe(1);
-    });
-});

package/dist/data/orm/table-container.test.d.ts

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

package/dist/data/orm/table-container.test.js

@@ -1,273 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const field_type_1 = require("../../types/field-type");
-const utils_1 = require("../../utils");
-const client_proxy_data_source_1 = require("./client-proxy.data-source");
-const event_registry_1 = require("./event-registry");
-const table_1 = require("./table");
-const table_container_1 = require("./table-container");
-describe("checkVersionedUpdate", () => {
-    const metaA = {
-        name: "TestTable",
-        fields: [{ name: "id", type: "string" }],
-    };
-    const metaAReordered = {
-        fields: [{ name: "id", type: "string" }],
-        name: "TestTable",
-    };
-    const metaB = {
-        name: "TestTable",
-        fields: [{ name: "id", type: "number" }],
-    };
-    it("should skip when existing version is strictly newer", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(200, 100, metaA, metaB)).toBe("skip");
-    });
-    it("should update when incoming version is strictly newer", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 200, metaA, metaB)).toBe("update");
-    });
-    it("should skip when same non-zero version and same definition", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaA)).toBe("skip");
-    });
-    it("should skip when same non-zero version and same definition with different key order", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaAReordered)).toBe("skip");
-    });
-    it("should skip when same non-zero version but different definitions", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 100, metaA, metaB)).toBe("skip");
-    });
-    it("should skip when both versions are 0 and definitions are the same", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaA)).toBe("skip");
-    });
-    it("should skip when both versions are 0 and definitions are the same with different key order", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaAReordered)).toBe("skip");
-    });
-    it("should skip when both versions are 0 and definitions differ", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(0, 0, metaA, metaB)).toBe("skip");
-    });
-    it("should update when incoming is newer regardless of definition content", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(50, 100, metaA, metaA)).toBe("update");
-        expect((0, table_container_1.checkVersionedUpdate)(50, 100, metaA, metaB)).toBe("update");
-    });
-    it("should skip when existing is newer regardless of definition content", () => {
-        expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaA)).toBe("skip");
-        expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaB)).toBe("skip");
-    });
-    it("ignores richer field metadata at the same version but still reports column changes", () => {
-        const report = jest.spyOn(console, "error").mockImplementation(() => { });
-        try {
-            const existing = {
-                ...metaA,
-                fields: [{ name: "detail", type: field_type_1.FieldType.object }],
-            };
-            const enriched = {
-                ...existing,
-                fields: [
-                    {
-                        type: field_type_1.FieldType.object,
-                        name: "detail",
-                        fields: [{ name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] }],
-                        future: "ignored",
-                    },
-                ],
-            };
-            expect((0, table_container_1.checkVersionedUpdate)(1, 1, existing, enriched)).toBe("skip");
-            expect(report).not.toHaveBeenCalled();
-            expect((0, table_container_1.checkVersionedUpdate)(1, 1, existing, {
-                ...enriched,
-                fields: [{ name: "detail", type: field_type_1.FieldType.string }],
-            })).toBe("skip");
-            expect(report).toHaveBeenCalledTimes(1);
-        }
-        finally {
-            report.mockRestore();
-        }
-    });
-});
-// --- Tiered table instance tests ---
-// Custom Table subclass for testing
-class CustomTestTable extends table_1.Table {
-    customMethod() {
-        return "custom";
-    }
-}
-function createTestHarness() {
-    const mockDataContext = { dataContextId: "test-context" };
-    const eventRegistry = new event_registry_1.EventRegistry(mockDataContext);
-    const tableFactory = jest
-        .fn()
-        .mockImplementation((metaData, schema, TableClass) => {
-        const deps = {
-            dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema ?? zod_1.z.object({}), "test-context"),
-            eventRegistry,
-        };
-        return new (TableClass || table_1.Table)(metaData, deps);
-    });
-    const container = new table_container_1.TableContainer(tableFactory);
-    const tableId = (0, utils_1.newid)();
-    const testMetaData = {
-        tableId,
-        name: "TestPkgTable",
-        description: "A package-defined table",
-        primaryKeyName: "id",
-        fields: [
-            { name: "id", type: field_type_1.FieldType.id },
-            { name: "title", type: field_type_1.FieldType.string },
-        ],
-    };
-    const testSchema = zod_1.z.object({
-        id: zod_1.z.string(),
-        title: zod_1.z.string(),
-    });
-    const defRecord = {
-        tableId,
-        name: `TestPkgTable_${tableId}`,
-        metaData: testMetaData,
-        versionNumber: 0,
-    };
-    return { container, testMetaData, testSchema, defRecord, tableFactory };
-}
-describe("Tiered table instances", () => {
-    it("bare-bones fallback instance should NOT block full instance with custom constructor", () => {
-        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
-        // Simulate sync: register from a TableDefinitionRecord (no custom constructor)
-        // (method is private — normally auto-called via dataChanged subscription)
-        container.registerFromTableDefinitionRecord(defRecord);
-        // Sync code calls getTableByName to get a working instance
-        const fallbackTable = container.getTableByName(defRecord.name);
-        expect(fallbackTable).toBeInstanceOf(table_1.Table);
-        expect(fallbackTable).not.toBeInstanceOf(CustomTestTable);
-        // Later, package code calls getTable with the full custom constructor
-        const fullTable = container.getTable(testMetaData, testSchema, CustomTestTable);
-        // The full instance should be a CustomTestTable, NOT the bare-bones Table
-        expect(fullTable).toBeInstanceOf(CustomTestTable);
-        expect(fullTable.customMethod()).toBe("custom");
-    });
-    it("getTableByName should return full instance when one exists", () => {
-        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
-        // Register fallback definition (private — normally auto-called)
-        container.registerFromTableDefinitionRecord(defRecord);
-        // Package code creates the full instance first
-        const fullTable = container.getTable(testMetaData, testSchema, CustomTestTable);
-        expect(fullTable).toBeInstanceOf(CustomTestTable);
-        // getTableByName should return the full instance, not create a new bare one
-        const byName = container.getTableByName(defRecord.name);
-        expect(byName).toBe(fullTable);
-        expect(byName).toBeInstanceOf(CustomTestTable);
-    });
-    it("getTableByName should return fallback instance when no full instance exists", () => {
-        const { container, defRecord } = createTestHarness();
-        // Only register from definition record -- no full definition available (private — normally auto-called)
-        container.registerFromTableDefinitionRecord(defRecord);
-        // Should return a bare-bones Table instance
-        const table = container.getTableByName(defRecord.name);
-        expect(table).toBeInstanceOf(table_1.Table);
-        expect(table).not.toBeInstanceOf(CustomTestTable);
-    });
-    it("getAllTables should prefer full instances over fallback instances", () => {
-        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
-        // Create a second table that will only have a fallback definition
-        const tableId2 = (0, utils_1.newid)();
-        const metaData2 = {
-            tableId: tableId2,
-            name: "OtherTable",
-            description: "Another table",
-            primaryKeyName: "id",
-            fields: [
-                { name: "id", type: field_type_1.FieldType.id },
-                { name: "value", type: field_type_1.FieldType.string },
-            ],
-        };
-        const defRecord2 = {
-            tableId: tableId2,
-            name: `OtherTable_${tableId2}`,
-            metaData: metaData2,
-            versionNumber: 0,
-        };
-        // Register both as fallback definitions (private — normally auto-called)
-        container.registerFromTableDefinitionRecord(defRecord);
-        container.registerFromTableDefinitionRecord(defRecord2);
-        // Create full instance for only the first table
-        container.getTable(testMetaData, testSchema, CustomTestTable);
-        // getAllTables should include both tables
-        const allTables = container.getAllTables();
-        const tableNames = allTables.map((t) => t.tableName);
-        expect(tableNames).toContain(defRecord.name);
-        expect(tableNames).toContain(defRecord2.name);
-        // The first table should be the full CustomTestTable instance
-        const firstTable = allTables.find((t) => t.tableName === defRecord.name);
-        expect(firstTable).toBeInstanceOf(CustomTestTable);
-        // The second table should be a bare-bones Table (fallback)
-        const secondTable = allTables.find((t) => t.tableName === defRecord2.name);
-        expect(secondTable).toBeInstanceOf(table_1.Table);
-        expect(secondTable).not.toBeInstanceOf(CustomTestTable);
-    });
-});
-describe("getLocalOnlyTableNames", () => {
-    it("returns localOnly code-registered table names and excludes non-local tables", () => {
-        const { container, testSchema } = createTestHarness();
-        const localOnlyMetaData = {
-            tableId: (0, utils_1.newid)(),
-            name: "LocalOnlyTable",
-            description: "A local-only table",
-            primaryKeyName: "id",
-            fields: [
-                { name: "id", type: field_type_1.FieldType.id },
-                { name: "title", type: field_type_1.FieldType.string },
-            ],
-            localOnly: true,
-        };
-        const syncedMetaData = {
-            tableId: (0, utils_1.newid)(),
-            name: "SyncedTable",
-            description: "A synced table",
-            primaryKeyName: "id",
-            fields: [
-                { name: "id", type: field_type_1.FieldType.id },
-                { name: "title", type: field_type_1.FieldType.string },
-            ],
-        };
-        container.registerTableDefinition({
-            metaData: localOnlyMetaData,
-            schema: testSchema,
-        });
-        container.registerTableDefinition({
-            metaData: syncedMetaData,
-            schema: testSchema,
-        });
-        const localOnlyNames = container.getLocalOnlyTableNames();
-        expect(localOnlyNames).toContain((0, utils_1.getFullTableName)(localOnlyMetaData));
-        expect(localOnlyNames).not.toContain((0, utils_1.getFullTableName)(syncedMetaData));
-    });
-    it("returns localOnly fallback table names without duplicates", () => {
-        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
-        const localOnlyMetaData = {
-            ...testMetaData,
-            localOnly: true,
-        };
-        const localOnlyDefRecord = {
-            ...defRecord,
-            metaData: localOnlyMetaData,
-        };
-        container.registerFromTableDefinitionRecord(localOnlyDefRecord);
-        container.registerTableDefinition({
-            metaData: localOnlyMetaData,
-            schema: testSchema,
-        });
-        const localOnlyNames = container.getLocalOnlyTableNames();
-        expect(localOnlyNames.filter((name) => name === defRecord.name)).toHaveLength(1);
-    });
-    it("lets a synced code definition supersede a local-only fallback", () => {
-        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
-        container.registerFromTableDefinitionRecord({
-            ...defRecord,
-            metaData: { ...testMetaData, localOnly: true, versionNumber: 1 },
-            versionNumber: 1,
-        });
-        expect(container.getLocalOnlyTableNames()).toContain(defRecord.name);
-        container.registerTableDefinition({
-            metaData: { ...testMetaData, versionNumber: 2 },
-            schema: testSchema,
-        });
-        expect(container.getLocalOnlyTableNames()).not.toContain(defRecord.name);
-    });
-});

package/dist/data/orm/table.event-source.test.d.ts

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