@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/orm/sql.data-source.test.js

@@ -3,17 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const SQLiteDB = require("better-sqlite3");
 const lodash_1 = require("lodash");
 const zod_1 = require("zod");
-const utils_1 = require("../../utils");
 const field_type_1 = require("../../types/field-type");
 const zod_types_1 = require("../../types/zod-types");
+const utils_1 = require("../../utils");
 const sql_data_source_1 = require("./sql.data-source");
 const types_1 = require("./types");
 class DBHarness {
     _db = null;
     get db() {
         if (!this._db) {
-            this._db = new SQLiteDB(':memory:');
-            this._db.pragma('journal_mode = WAL');
+            this._db = new SQLiteDB(":memory:");
+            this._db.pragma("journal_mode = WAL");
         }
         return this._db;
     }
@@ -32,52 +32,52 @@ class DBHarness {
         this._db = null;
     }
 }
-let db = new DBHarness();
-describe('table', () => {
+const db = new DBHarness();
+describe("table", () => {
     const fiveMinutesMs = 5 * 60 * 1000; // 5 minutes in milliseconds
     jest.setTimeout(fiveMinutesMs);
     afterAll(async () => {
         db.db?.close();
     });
-    describe('when type is defined in code', () => {
+    describe("when type is defined in code", () => {
         const taskSchema = zod_1.z.object({
             taskId: zod_types_1.zodPeerId.default(() => (0, utils_1.newid)()),
             title: zod_1.z.string(),
-            body: zod_1.z.string().default(''),
+            body: zod_1.z.string().default(""),
             dueDate: zod_1.z.date().optional(),
             completeDT: zod_1.z.date().optional(),
             parentTaskId: zod_types_1.zodPeerId.optional(),
         });
         const taskFields = (0, types_1.schemaToFields)(taskSchema);
         const tasksTableType = {
-            name: 'test_tasks_code_driven',
-            description: 'Task',
-            primaryKeyName: 'taskId',
+            name: "test_tasks_code_driven",
+            description: "Task",
+            primaryKeyName: "taskId",
             fields: taskFields,
             indexes: [
-                { fields: ['title'] },
-                { unique: true, fields: ['taskId', { name: 'parentTaskId', order: 'DESC' }] }
+                { fields: ["title"] },
+                { unique: true, fields: ["taskId", { name: "parentTaskId", order: "DESC" }] },
             ],
         };
         const TasksTable = new sql_data_source_1.SQLDataSource(db, tasksTableType);
         beforeAll(async () => {
             await TasksTable.dropTableIfExists();
         });
-        it('should do compile time checks and runtime typechecks', async () => {
+        it("should do compile time checks and runtime typechecks", async () => {
             const badSavePromise = TasksTable.save({
-                // @ts-expect-error - making sure type checking is working
-                id: 'test', title: 1,
-                body: 'This is a test task',
+                id: "test",
+                title: 1,
+                body: "This is a test task",
                 dueDate: new Date(),
             });
             // await expect(badSavePromise).rejects.toThrow(`SQLITE_ERROR: table ${tableName} has no column named id`);
             await expect(badSavePromise).rejects.toThrow(/validation.*failed.*title.*expected string, received number/ims);
         });
-        it('should do all CRUD operations', async () => {
+        it("should do all CRUD operations", async () => {
             const task1 = {
                 taskId: (0, utils_1.newid)(),
-                title: 'Test Task',
-                body: 'This is a test task',
+                title: "Test Task",
+                body: "This is a test task",
                 dueDate: new Date(),
             };
             // CREATE
@@ -86,7 +86,7 @@ describe('table', () => {
             let task1Db = await TasksTable.get(task1.taskId);
             expect(task1Db).toEqual(task1);
             // UPDATE
-            task1.title = 'Updated Task';
+            task1.title = "Updated Task";
             await TasksTable.save(task1);
             task1Db = await TasksTable.get(task1.taskId);
             expect(task1Db).toEqual(task1);
@@ -95,24 +95,24 @@ describe('table', () => {
             task1Db = await TasksTable.get(task1.taskId);
             expect(task1Db).toBeUndefined();
         });
-        it('should enable type-checked queries', async () => {
+        it("should enable type-checked queries", async () => {
             const task1 = {
                 taskId: (0, utils_1.newid)(),
-                title: 'Test Task',
-                body: 'This is a test task',
+                title: "Test Task",
+                body: "This is a test task",
                 dueDate: new Date(),
             };
             // CREATE
             await TasksTable.save(task1);
             // query
-            const results = await TasksTable.list({ title: 'Test Task' });
+            const results = await TasksTable.list({ title: "Test Task" });
             expect(results[0]).toEqual(task1);
-            // // @ts-expect-error - making sure type checking is working      
+            // // @ts-expect-error - making sure type checking is working
             // const badQueryResults = await TasksTable.list({ id: 'test' });
             // // note that sqlite does not check that columns exist, so this query succeeds with no matches
             // expect(badQueryResults).toEqual([]);
             // @ts-expect-error - making sure type checking is working
-            const badQueryPromise = TasksTable.list({ id: 'test' });
+            const badQueryPromise = TasksTable.list({ id: "test" });
             // SQLite error messages vary by version - some throw "no such column", others succeed with empty results
             // The important thing is that TypeScript catches this at compile time with @ts-expect-error
             // await expect(badQueryPromise).rejects.toThrow(`SQLITE_ERROR: table ${tableName} has no column named id`);
@@ -130,35 +130,35 @@ describe('table', () => {
                 expect(error.message).toMatch(/id|column/i);
             }
         });
-        it('should validate the data before saving', async () => {
+        it("should validate the data before saving", async () => {
             // test validates a bad date
             {
                 const badTask = {
                     taskId: (0, utils_1.newid)(),
-                    title: 'Test Task',
-                    body: 'This is a test task',
-                    dueDate: 'not a date',
+                    title: "Test Task",
+                    body: "This is a test task",
+                    dueDate: "not a date",
                 };
                 const badSavePromise = TasksTable.save(badTask);
-                await expect(badSavePromise).rejects.toThrow('Expected date, received string');
+                await expect(badSavePromise).rejects.toThrow("Expected date, received string");
             }
             // test validates a bad id
             {
                 const badTask = {
-                    taskId: 'not an id',
-                    title: 'Test Task',
-                    body: 'This is a test task',
+                    taskId: "not an id",
+                    title: "Test Task",
+                    body: "This is a test task",
                     dueDate: new Date(),
                 };
                 const badSavePromise = TasksTable.save(badTask);
-                await expect(badSavePromise).rejects.toThrow('Invalid id');
+                await expect(badSavePromise).rejects.toThrow("Invalid id");
             }
             // add task to database
             const existingTaskId = (0, utils_1.newid)();
             const task1 = {
                 taskId: existingTaskId,
-                title: 'Test Task',
-                body: 'This is a test task',
+                title: "Test Task",
+                body: "This is a test task",
                 dueDate: new Date(),
             };
             await TasksTable.save(task1);
@@ -170,8 +170,8 @@ describe('table', () => {
                 expect(existingRecord?.taskId).toBe(existingTaskId);
                 const badTask = {
                     taskId: existingTaskId,
-                    title: 'Test Task',
-                    body: 'This is a test task',
+                    title: "Test Task",
+                    body: "This is a test task",
                     dueDate: new Date(),
                 };
                 // Try-catch approach to handle environments where UNIQUE constraint might not throw
@@ -180,7 +180,7 @@ describe('table', () => {
                     await TasksTable.insert(badTask);
                     // If we get here without throwing, the test should fail
                     // This can happen in some SQLite configurations that don't enforce UNIQUE constraints properly
-                    fail('Expected insert to throw UNIQUE constraint error, but it succeeded');
+                    fail("Expected insert to throw UNIQUE constraint error, but it succeeded");
                 }
                 catch (error) {
                     // Verify the error is related to UNIQUE constraint or primary key
@@ -191,18 +191,18 @@ describe('table', () => {
             {
                 const badTask = {
                     taskId: existingTaskId,
-                    title: 'Test Task',
-                    body: 'This is a test task',
-                    dueDate: 'not a date',
+                    title: "Test Task",
+                    body: "This is a test task",
+                    dueDate: "not a date",
                 };
                 const badSavePromise = TasksTable.update(badTask);
-                await expect(badSavePromise).rejects.toThrow('Expected date, received string');
+                await expect(badSavePromise).rejects.toThrow("Expected date, received string");
             }
         });
-        it('should allow initializing a record with only part of the data', async () => {
+        it("should allow initializing a record with only part of the data", async () => {
             const newTask = TasksTable.initRecord();
             expect(() => TasksTable.schema.parse(newTask)).toThrow();
-            newTask.title = 'Test Task';
+            newTask.title = "Test Task";
             expect(() => TasksTable.schema.parse(newTask)).not.toThrow();
         });
         afterAll(async () => {
@@ -210,39 +210,39 @@ describe('table', () => {
             await TasksTable.db.close();
         });
     });
-    describe('when type is loaded from database', () => {
+    describe("when type is loaded from database", () => {
         const tasksTableType = {
-            name: 'test_tasks_data_driven',
-            description: 'Task',
-            primaryKeyName: 'taskId',
+            name: "test_tasks_data_driven",
+            description: "Task",
+            primaryKeyName: "taskId",
             fields: [
-                { name: 'taskId', description: 'Task ID', type: field_type_1.FieldType.id },
-                { name: 'title', description: 'Title', type: field_type_1.FieldType.string },
-                { name: 'body', description: 'Body', type: field_type_1.FieldType.string },
-                { name: 'dueDate', description: 'Due Date', type: field_type_1.FieldType.Date, optional: true },
-                { name: 'completeDT', description: 'Complete Date', type: field_type_1.FieldType.Date, optional: true },
-                { name: 'parentTaskId', description: 'Parent Task ID', type: field_type_1.FieldType.id, optional: true },
+                { name: "taskId", description: "Task ID", type: field_type_1.FieldType.id },
+                { name: "title", description: "Title", type: field_type_1.FieldType.string },
+                { name: "body", description: "Body", type: field_type_1.FieldType.string },
+                { name: "dueDate", description: "Due Date", type: field_type_1.FieldType.Date, optional: true },
+                { name: "completeDT", description: "Complete Date", type: field_type_1.FieldType.Date, optional: true },
+                { name: "parentTaskId", description: "Parent Task ID", type: field_type_1.FieldType.id, optional: true },
             ],
         };
         const TasksTable = new sql_data_source_1.SQLDataSource(db, tasksTableType);
         beforeAll(async () => {
             await TasksTable.dropTableIfExists();
         });
-        it('should do runtime typechecks', async () => {
+        it("should do runtime typechecks", async () => {
             const badSavePromise = TasksTable.save({
-                id: 'test',
+                id: "test",
                 title: 1,
-                body: 'This is a test task',
+                body: "This is a test task",
                 dueDate: new Date(),
             });
             // await expect(badSavePromise).rejects.toThrow(`SQLITE_ERROR: table ${tableName} has no column named id`);
             await expect(badSavePromise).rejects.toThrow(/validation.*failed.*title.*expected string, received number/ims);
         });
-        it('should do all CRUD operations', async () => {
+        it("should do all CRUD operations", async () => {
             const task1 = {
                 taskId: (0, utils_1.newid)(),
-                title: 'Test Task',
-                body: 'This is a test task',
+                title: "Test Task",
+                body: "This is a test task",
                 dueDate: new Date(),
             };
             // CREATE
@@ -251,7 +251,7 @@ describe('table', () => {
             let task1Db = await TasksTable.get(task1.taskId);
             expect(task1Db).toEqual(task1);
             // UPDATE
-            task1.title = 'Updated Task';
+            task1.title = "Updated Task";
             await TasksTable.save(task1);
             task1Db = await TasksTable.get(task1.taskId);
             expect(task1Db).toEqual(task1);
@@ -265,34 +265,37 @@ describe('table', () => {
             await TasksTable.db.close();
         });
     });
-    describe('when the schema has changed', () => {
+    describe("when the schema has changed", () => {
         const notesTableTypeV1 = {
-            name: 'test_table_notes',
-            description: 'Notes',
-            primaryKeyName: 'entryId',
+            name: "test_table_notes",
+            description: "Notes",
+            primaryKeyName: "entryId",
             fields: [
-                { name: 'entryId', description: 'Entry ID', type: field_type_1.FieldType.id },
-                { name: 'title', description: 'Title', type: field_type_1.FieldType.string },
-                { name: 'body', description: 'Body', type: field_type_1.FieldType.string, defaultValue: '' },
-            ],
-            indexes: [
-                { fields: ['title'] },
+                { name: "entryId", description: "Entry ID", type: field_type_1.FieldType.id },
+                { name: "title", description: "Title", type: field_type_1.FieldType.string },
+                { name: "body", description: "Body", type: field_type_1.FieldType.string, defaultValue: "" },
             ],
+            indexes: [{ fields: ["title"] }],
         };
         const NotesTableV1 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV1);
         beforeAll(async () => {
             await NotesTableV1.dropTableIfExists();
             await NotesTableV1.list();
         });
-        it('should not update table if already up to date', async () => {
+        it("should not update table if already up to date", async () => {
             const updated = await NotesTableV1.initTable(true);
             expect(updated).toBe(false);
         });
-        it('should detect column changes and modify tables to match', async () => {
-            const v1Note = await NotesTableV1.insert({ title: 'Test Note', body: 'This is a test note' });
+        it("should detect column changes and modify tables to match", async () => {
+            const v1Note = await NotesTableV1.insert({ title: "Test Note", body: "This is a test note" });
             // add optional number column
             const notesTableTypeV2 = (0, lodash_1.cloneDeep)(notesTableTypeV1);
-            notesTableTypeV2.fields.push({ name: 'priority', description: 'Priority of note', type: field_type_1.FieldType.number, optional: true });
+            notesTableTypeV2.fields.push({
+                name: "priority",
+                description: "Priority of note",
+                type: field_type_1.FieldType.number,
+                optional: true,
+            });
             const NotesTableV2 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV2);
             const updatedToV2 = await NotesTableV2.initTable(true);
             expect(updatedToV2).toBe(true);
@@ -300,12 +303,17 @@ describe('table', () => {
             expect(v2Note).toEqual({ ...v1Note });
             // add required date column
             const notesTableTypeV3 = (0, lodash_1.cloneDeep)(notesTableTypeV2);
-            notesTableTypeV3.fields.push({ name: 'modified', description: 'Last time this was modified', type: field_type_1.FieldType.Date, defaultValue: () => new Date() });
+            notesTableTypeV3.fields.push({
+                name: "modified",
+                description: "Last time this was modified",
+                type: field_type_1.FieldType.Date,
+                defaultValue: () => new Date(),
+            });
             const NotesTableV3 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV3);
             const updatedToV3 = await NotesTableV3.initTable(true);
             expect(updatedToV3).toBe(true);
             const v3Note = await NotesTableV3.get(v1Note.entryId);
-            expect(v3Note).toEqual({ ...v1Note, modified: v3Note.modified });
+            expect(v3Note).toEqual({ ...v1Note, modified: v3Note?.modified });
             // remove column
             const notesTableTypeV4 = (0, lodash_1.cloneDeep)(notesTableTypeV3);
             notesTableTypeV4.fields.pop();
@@ -326,9 +334,9 @@ describe('table', () => {
             const updatedToV5Again = await NotesTableV5.initTable(true);
             expect(updatedToV5Again).toBe(false);
         });
-        it('should detect and change column indexes', async () => {
+        it("should detect and change column indexes", async () => {
             const notesTableTypeV1Indexes = (0, lodash_1.cloneDeep)(notesTableTypeV1);
-            notesTableTypeV1Indexes.name += '_indexes';
+            notesTableTypeV1Indexes.name += "_indexes";
             const NotesTableV1 = new sql_data_source_1.SQLDataSource(db, notesTableTypeV1Indexes);
             await NotesTableV1.dropTableIfExists();
             await NotesTableV1.initTable(true);
@@ -345,26 +353,26 @@ describe('table', () => {
             expect(indexesV2).toHaveLength(1);
         });
     });
-    describe('when the field type is `object`', () => {
+    describe("when the field type is `object`", () => {
         const tableType = {
-            name: 'test_table_objects',
-            description: 'Objects',
-            primaryKeyName: 'objectId',
+            name: "test_table_objects",
+            description: "Objects",
+            primaryKeyName: "objectId",
             fields: [
-                { name: 'objectId', description: 'Object ID', type: field_type_1.FieldType.id },
-                { name: 'name', description: 'Name', type: field_type_1.FieldType.string },
-                { name: 'data', description: 'Data', type: field_type_1.FieldType.object },
+                { name: "objectId", description: "Object ID", type: field_type_1.FieldType.id },
+                { name: "name", description: "Name", type: field_type_1.FieldType.string },
+                { name: "data", description: "Data", type: field_type_1.FieldType.object },
             ],
         };
         const ObjectsTable = new sql_data_source_1.SQLDataSource(db, tableType);
         beforeAll(async () => {
             await ObjectsTable.dropTableIfExists();
         });
-        it('should store objects as JSON strings', async () => {
+        it("should store objects as JSON strings", async () => {
             const obj = {
                 objectId: (0, utils_1.newid)(),
-                name: 'Test Object',
-                data: { test: 'data' },
+                name: "Test Object",
+                data: { test: "data" },
             };
             await ObjectsTable.save(obj);
             const objDb = await ObjectsTable.get(obj.objectId);
@@ -375,26 +383,26 @@ describe('table', () => {
             await ObjectsTable.db.close();
         });
     });
-    describe('when the field type is an array of primitives', () => {
+    describe("when the field type is an array of primitives", () => {
         const tableType = {
-            name: 'test_table_arrays',
-            description: 'Arrays',
-            primaryKeyName: 'arrayId',
+            name: "test_table_arrays",
+            description: "Arrays",
+            primaryKeyName: "arrayId",
             fields: [
-                { name: 'arrayId', description: 'Array ID', type: field_type_1.FieldType.id },
-                { name: 'name', description: 'Name', type: field_type_1.FieldType.string },
-                { name: 'data', description: 'Data', type: field_type_1.FieldType.string, isArray: true },
+                { name: "arrayId", description: "Array ID", type: field_type_1.FieldType.id },
+                { name: "name", description: "Name", type: field_type_1.FieldType.string },
+                { name: "data", description: "Data", type: field_type_1.FieldType.string, isArray: true },
             ],
         };
         const ArraysTable = new sql_data_source_1.SQLDataSource(db, tableType);
         beforeAll(async () => {
             await ArraysTable.dropTableIfExists();
         });
-        it('should store arrays as JSON strings and automatically rehydrate them', async () => {
+        it("should store arrays as JSON strings and automatically rehydrate them", async () => {
             const obj = {
                 arrayId: (0, utils_1.newid)(),
-                name: 'Test Array',
-                data: ['test', 'data'],
+                name: "Test Array",
+                data: ["test", "data"],
             };
             await ArraysTable.save(obj);
             const objDb = await ArraysTable.get(obj.arrayId);

package/dist/data/orm/subscribable.data-source.d.ts

@@ -1,9 +1,9 @@
-import { Emitter, Event } from "../../events";
-import { DataFilter, ICursorIterable, IDataQueryParams, IDataSource } from "./data-query";
+import { Emitter, type Event } from "../../events";
+import { type DataFilter, type ICursorIterable, type IDataQueryParams, type IDataSource } from "./data-query";
 export interface IDataChangedEvent<T> {
     dataObject: T;
-    op: 'insert' | 'update' | 'delete';
-    source: 'local' | 'remote';
+    op: "insert" | "update" | "delete";
+    source: "local" | "remote";
 }
 export declare class SubscribableDataSource<T extends {
     [key: string]: any;

package/dist/data/orm/subscribable.data-source.js

@@ -15,7 +15,7 @@ class SubscribableDataSource {
         this.tableName = dataSource.tableName;
         this.primaryKeyName = dataSource.primaryKeyName;
         // ensure different data source emitters for the same table have different names
-        let eventNameCount = eventNameCounts.get(this.tableName) || 0;
+        const eventNameCount = eventNameCounts.get(this.tableName) || 0;
         eventNameCounts.set(this.tableName, eventNameCount + 1);
         const eventName = `SubscribableDataSource_${this.tableName}_DataChanged_${eventNameCount}`;
         this.dataChangedEmitter = new events_1.Emitter(eventName);
@@ -51,22 +51,22 @@ class SubscribableDataSource {
     }
     async insert(record) {
         record = await this.dataSource.insert(record);
-        this.dataChangedEmitter.emit({ dataObject: record, op: 'insert', source: 'local' });
+        this.dataChangedEmitter.emit({ dataObject: record, op: "insert", source: "local" });
         return record;
     }
     async update(record) {
         record = await this.dataSource.update(record);
-        this.dataChangedEmitter.emit({ dataObject: record, op: 'update', source: 'local' });
+        this.dataChangedEmitter.emit({ dataObject: record, op: "update", source: "local" });
         return record;
     }
     async delete(idOrRecord) {
-        const id = typeof idOrRecord === 'string' ? idOrRecord : idOrRecord[this.primaryKeyName];
+        const id = typeof idOrRecord === "string" ? idOrRecord : idOrRecord[this.primaryKeyName];
         const record = await this.get(id);
         if (!record) {
             return;
         }
         await this.dataSource.delete(idOrRecord);
-        this.dataChangedEmitter.emit({ dataObject: record, op: 'delete', source: 'local' });
+        this.dataChangedEmitter.emit({ dataObject: record, op: "delete", source: "local" });
     }
 }
 exports.SubscribableDataSource = SubscribableDataSource;

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

@@ -1,45 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const table_container_1 = require("./table-container");
-const event_registry_1 = require("./event-registry");
-const client_proxy_data_source_1 = require("./client-proxy.data-source");
 const field_type_1 = require("../../types/field-type");
-describe('TableFactory Event Sharing', () => {
+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',
+        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 },
+            { 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', () => {
+    it("should share event emitters when using the same EventRegistry", () => {
         // Create mock data context for event registry
         const mockDataContext = {
-            dataContextId: 'test-context'
+            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 tableFactory1 = jest
+            .fn()
+            .mockImplementation((metaData, schema, TableClass) => {
             const deps = {
-                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, 'test-context'),
+                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, "test-context"),
                 eventRegistry: sharedRegistry,
             };
-            return new (TableClass || require('./table').Table)(metaData, deps);
+            return new (TableClass || require("./table").Table)(metaData, deps);
         });
-        const tableFactory2 = jest.fn().mockImplementation((metaData, schema, TableClass) => {
+        const tableFactory2 = jest
+            .fn()
+            .mockImplementation((metaData, schema, TableClass) => {
             const deps = {
-                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, 'test-context'),
+                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, "test-context"),
                 eventRegistry: sharedRegistry,
             };
-            return new (TableClass || require('./table').Table)(metaData, deps);
+            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);
@@ -54,27 +58,31 @@ describe('TableFactory Event Sharing', () => {
         // 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', () => {
+    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' };
+        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 tableFactory1 = jest
+            .fn()
+            .mockImplementation((metaData, schema, TableClass) => {
             const deps = {
-                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, 'test-context'),
+                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, "test-context"),
                 eventRegistry: registry1,
             };
-            return new (TableClass || require('./table').Table)(metaData, deps);
+            return new (TableClass || require("./table").Table)(metaData, deps);
         });
-        const tableFactory2 = jest.fn().mockImplementation((metaData, schema, TableClass) => {
+        const tableFactory2 = jest
+            .fn()
+            .mockImplementation((metaData, schema, TableClass) => {
             const deps = {
-                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, 'test-context'),
+                dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema || testSchema, "test-context"),
                 eventRegistry: registry2,
             };
-            return new (TableClass || require('./table').Table)(metaData, deps);
+            return new (TableClass || require("./table").Table)(metaData, deps);
         });
         // Create two table containers with different registries
         const container1 = new table_container_1.TableContainer(tableFactory1);

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

@@ -1,13 +1,13 @@
-import { z } from 'zod';
-import { ITableMetaData } from './types';
-import { Table } from './table';
-import { ITableDefinition, TableFactory, TableConstructor } from './table-definitions.type';
+import type { z } from "zod";
+import { Table } from "./table";
+import type { ITableDefinition, TableConstructor, TableFactory } from "./table-definitions.type";
+import { type ITableMetaData } from "./types";
 /**
  * Compare two table definition versions and decide whether to update.
  * @returns 'update' when incoming version is strictly newer, 'skip' otherwise.
  * Logs an error if same version but different definitions (caller should bump versionNumber).
  */
-export declare function checkVersionedUpdate(existingVersion: number, incomingVersion: number, existingMetaData: ITableMetaData, incomingMetaData: ITableMetaData): 'update' | 'skip';
+export declare function checkVersionedUpdate(existingVersion: number, incomingVersion: number, existingMetaData: ITableMetaData, incomingMetaData: ITableMetaData): "update" | "skip";
 export declare class TableContainer {
     readonly tableFactory: TableFactory;
     readonly groupId?: string | undefined;
@@ -67,6 +67,6 @@ export declare class TableContainer {
      *
      * This is primarily intended to be used by the peer-device sync operation which needs all
      * tables to be able to apply changes correctly.
-    */
+     */
     getAllTables(): Table<any>[];
 }