@peers-app/peers-sdk 0.27.3 → 0.27.4

package/dist/data/orm/table.event-source.test.js

@@ -1,331 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const field_type_1 = require("../../types/field-type");
-const utils_1 = require("../../utils");
-const event_registry_1 = require("./event-registry");
-const subscribable_data_source_1 = require("./subscribable.data-source");
-const table_1 = require("./table");
-const types_1 = require("./types");
-// Mock data source for testing
-class MockDataSource {
-    tableName;
-    primaryKeyName;
-    data = new Map();
-    constructor(tableName, primaryKeyName = "id", initialData = []) {
-        this.tableName = tableName;
-        this.primaryKeyName = primaryKeyName;
-        initialData.forEach((item) => {
-            this.data.set(item[primaryKeyName], item);
-        });
-    }
-    async get(id) {
-        return this.data.get(id);
-    }
-    async list() {
-        return Array.from(this.data.values());
-    }
-    async save(record) {
-        const id = record[this.primaryKeyName];
-        if (id && this.data.has(id)) {
-            return this.update(record);
-        }
-        else {
-            return this.insert(record);
-        }
-    }
-    async insert(record) {
-        if (!record[this.primaryKeyName]) {
-            // Create a new record with the generated ID
-            record = { ...record, [this.primaryKeyName]: (0, utils_1.newid)() };
-        }
-        this.data.set(record[this.primaryKeyName], record);
-        return record;
-    }
-    async update(record) {
-        const id = record[this.primaryKeyName];
-        if (!this.data.has(id)) {
-            throw new Error(`Record with id ${id} not found`);
-        }
-        this.data.set(id, record);
-        return record;
-    }
-    async delete(idOrRecord) {
-        const id = typeof idOrRecord === "string" ? idOrRecord : idOrRecord[this.primaryKeyName];
-        this.data.delete(id);
-    }
-}
-describe("Table Event Source Functionality", () => {
-    let table;
-    let underlyingDataSource;
-    let subscribableDataSource;
-    let capturedEvents;
-    const testMetadata = {
-        name: "TestTable",
-        description: "Test table for event source functionality",
-        primaryKeyName: "id",
-        fields: [
-            { name: "id", type: field_type_1.FieldType.id, description: "Primary key" },
-            { name: "name", type: field_type_1.FieldType.string, description: "Name field" },
-            { name: "age", type: field_type_1.FieldType.number, description: "Age field" },
-        ],
-    };
-    const testSchema = (0, types_1.fieldsToSchema)(testMetadata.fields);
-    const testRecord = {
-        id: "test-1",
-        name: "John Doe",
-        age: 30,
-    };
-    beforeEach(() => {
-        capturedEvents = [];
-        // Create underlying data source with unique name to avoid conflicts
-        const uniqueTableName = `TestTable_${Date.now()}_${Math.random()}`;
-        underlyingDataSource = new MockDataSource(uniqueTableName, "id");
-        // Wrap it in a SubscribableDataSource
-        subscribableDataSource = new subscribable_data_source_1.SubscribableDataSource(underlyingDataSource);
-        // Create real event registry for testing
-        const mockDataContextForRegistry = {
-            dataContextId: "test-context",
-        };
-        const eventRegistry = new event_registry_1.EventRegistry(mockDataContextForRegistry);
-        const _mockDataContext = {
-            dataSourceFactory: () => subscribableDataSource,
-            eventRegistry: eventRegistry,
-        };
-        // Create table with the subscribable data source
-        const metaData = {
-            ...testMetadata,
-            name: uniqueTableName,
-        };
-        const deps = {
-            dataSource: subscribableDataSource,
-            eventRegistry: eventRegistry,
-            schema: testSchema,
-        };
-        table = new table_1.Table(metaData, deps);
-        // Subscribe to events to capture them
-        table.dataChanged.subscribe((event) => {
-            capturedEvents.push(event);
-        });
-    });
-    describe("Local Operations", () => {
-        it("should mark insert events as local when called from table", async () => {
-            await table.insert(testRecord);
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0]).toEqual({
-                dataObject: testRecord,
-                op: "insert",
-                source: "local",
-            });
-        });
-        it("should mark update events as local when called from table", async () => {
-            // First insert the record
-            await table.insert(testRecord);
-            capturedEvents.length = 0; // Clear events
-            const updatedRecord = { ...testRecord, age: 31 };
-            await table.update(updatedRecord);
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0]).toEqual({
-                dataObject: updatedRecord,
-                op: "update",
-                source: "local",
-            });
-        });
-        it("should mark delete events as local when called from table", async () => {
-            // First insert the record
-            await table.insert(testRecord);
-            capturedEvents.length = 0; // Clear events
-            await table.delete(testRecord.id);
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0]).toEqual({
-                dataObject: testRecord,
-                op: "delete",
-                source: "local",
-            });
-        });
-        it("should mark save events as local (insert case)", async () => {
-            await table.save(testRecord);
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0]).toEqual({
-                dataObject: testRecord,
-                op: "insert",
-                source: "local",
-            });
-        });
-        it("should mark save events as local (update case)", async () => {
-            // First insert the record directly to underlying source
-            await underlyingDataSource.insert(testRecord);
-            capturedEvents.length = 0; // Clear events
-            const updatedRecord = { ...testRecord, age: 31 };
-            await table.save(updatedRecord);
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0]).toEqual({
-                dataObject: updatedRecord,
-                op: "update",
-                source: "local",
-            });
-        });
-    });
-    describe("Remote Operations", () => {
-        it("should mark insert events as remote when called from underlying source", async () => {
-            await subscribableDataSource.insert(testRecord);
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0]).toEqual({
-                dataObject: testRecord,
-                op: "insert",
-                source: "remote",
-            });
-        });
-        it("should mark update events as remote when called from underlying source", async () => {
-            // First insert the record
-            await subscribableDataSource.insert(testRecord);
-            capturedEvents.length = 0; // Clear events
-            const updatedRecord = { ...testRecord, age: 31 };
-            await subscribableDataSource.update(updatedRecord);
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0]).toEqual({
-                dataObject: updatedRecord,
-                op: "update",
-                source: "remote",
-            });
-        });
-        it("should mark delete events as remote when called from underlying source", async () => {
-            // First insert the record
-            await subscribableDataSource.insert(testRecord);
-            capturedEvents.length = 0; // Clear events
-            await subscribableDataSource.delete(testRecord.id);
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0]).toEqual({
-                dataObject: testRecord,
-                op: "delete",
-                source: "remote",
-            });
-        });
-    });
-    describe("Concurrent Operations", () => {
-        it("should handle multiple concurrent insert operations correctly", async () => {
-            const record1 = { id: "test-1", name: "John", age: 30 };
-            const record2 = { id: "test-2", name: "Jane", age: 25 };
-            const record3 = { id: "test-3", name: "Bob", age: 35 };
-            // Execute multiple operations concurrently
-            await Promise.all([table.insert(record1), table.insert(record2), table.insert(record3)]);
-            expect(capturedEvents).toHaveLength(3);
-            capturedEvents.forEach((event) => {
-                expect(event.op).toBe("insert");
-                expect(event.source).toBe("local");
-            });
-            // Verify all records were inserted
-            const insertedIds = capturedEvents.map((e) => e.dataObject.id).sort();
-            expect(insertedIds).toEqual(["test-1", "test-2", "test-3"]);
-        });
-        it("should handle concurrent operations with different operations types", async () => {
-            const record1 = { id: "test-1", name: "John", age: 30 };
-            const record2 = { id: "test-2", name: "Jane", age: 25 };
-            // First insert records to set up for update/delete
-            await table.insert(record1);
-            await table.insert(record2);
-            capturedEvents.length = 0; // Clear events
-            const updatedRecord1 = { ...record1, age: 31 };
-            const record3 = { id: "test-3", name: "Alice", age: 28 };
-            // Execute mixed operations concurrently
-            await Promise.all([
-                table.update(updatedRecord1),
-                table.delete(record2.id),
-                table.insert(record3),
-            ]);
-            expect(capturedEvents).toHaveLength(3);
-            // All should be marked as local
-            capturedEvents.forEach((event) => {
-                expect(event.source).toBe("local");
-            });
-            // Check specific operations
-            const operations = capturedEvents.map((e) => e.op).sort();
-            expect(operations).toEqual(["delete", "insert", "update"]);
-        });
-        it("should handle concurrent local and remote operations correctly", async () => {
-            const localRecord = { id: "local-1", name: "Local User", age: 30 };
-            const remoteRecord = { id: "remote-1", name: "Remote User", age: 25 };
-            // Execute local and remote operations concurrently
-            await Promise.all([table.insert(localRecord), subscribableDataSource.insert(remoteRecord)]);
-            expect(capturedEvents).toHaveLength(2);
-            // Find events by record ID
-            const localEvent = capturedEvents.find((e) => e.dataObject.id === "local-1");
-            const remoteEvent = capturedEvents.find((e) => e.dataObject.id === "remote-1");
-            expect(localEvent?.source).toBe("local");
-            expect(remoteEvent?.source).toBe("remote");
-        });
-        it("should handle concurrent operations on different records correctly", async () => {
-            const record1 = { id: "test-1", name: "John", age: 30 };
-            const record2 = { id: "test-2", name: "Jane", age: 25 };
-            // Insert records first
-            await table.insert(record1);
-            await subscribableDataSource.insert(record2);
-            capturedEvents.length = 0;
-            const localUpdate = { ...record1, name: "John Local", age: 31 };
-            const remoteUpdate = { ...record2, name: "Jane Remote", age: 26 };
-            // Execute concurrent updates on different records (one local, one remote)
-            await Promise.all([table.update(localUpdate), subscribableDataSource.update(remoteUpdate)]);
-            expect(capturedEvents).toHaveLength(2);
-            // Both operations should complete, but with different sources
-            const localEvent = capturedEvents.find((e) => e.dataObject.name?.includes("Local"));
-            const remoteEvent = capturedEvents.find((e) => e.dataObject.name?.includes("Remote"));
-            expect(localEvent?.source).toBe("local");
-            expect(remoteEvent?.source).toBe("remote");
-        });
-    });
-    describe("Cache Management", () => {
-        it("should clean up cache entries after operations complete", async () => {
-            const record = { id: "test-1", name: "John", age: 30 };
-            // Insert record
-            await table.insert(record);
-            // Verify the cache was cleaned up by checking that subsequent remote operations
-            // are marked as remote (not local)
-            const updatedRecord = { ...record, age: 31 };
-            await subscribableDataSource.update(updatedRecord);
-            expect(capturedEvents).toHaveLength(2);
-            expect(capturedEvents[0].source).toBe("local"); // Insert
-            expect(capturedEvents[1].source).toBe("remote"); // Update from subscribable source
-        });
-        it("should clean up cache entries even when operations throw errors", async () => {
-            const record = { id: "nonexistent", name: "John", age: 30 };
-            // Try to update a non-existent record (should throw)
-            try {
-                await table.update(record);
-            }
-            catch (_error) {
-                // Expected to throw
-            }
-            // Now insert the same record through underlying source
-            await subscribableDataSource.insert(record);
-            // Should be marked as remote since cache was cleaned up
-            expect(capturedEvents).toHaveLength(1);
-            expect(capturedEvents[0].source).toBe("remote");
-        });
-    });
-    describe("Table Without Underlying SubscribableDataSource", () => {
-        it("should work correctly when no underlying SubscribableDataSource exists", async () => {
-            // Create table with plain data source (no SubscribableDataSource)
-            const plainDataSource = new MockDataSource("PlainTable", "id");
-            const mockDataContextForRegistry2 = {
-                dataContextId: "test-context-2",
-            };
-            const eventRegistry2 = new event_registry_1.EventRegistry(mockDataContextForRegistry2);
-            const _mockDataContext = {
-                dataSourceFactory: () => plainDataSource,
-                eventRegistry: eventRegistry2,
-            };
-            const plainTableDeps = {
-                dataSource: plainDataSource,
-                eventRegistry: eventRegistry2,
-                schema: testSchema,
-            };
-            const plainTable = new table_1.Table(testMetadata, plainTableDeps);
-            const events = [];
-            plainTable.dataChanged.subscribe((event) => {
-                events.push(event);
-            });
-            await plainTable.insert(testRecord);
-            expect(events).toHaveLength(1);
-            expect(events[0].source).toBe("local");
-        });
-    });
-});

package/dist/data/orm/types.test.d.ts

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