@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const table_1 = require("./table");
-const subscribable_data_source_1 = require("./subscribable.data-source");
-const types_1 = require("./types");
 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 = []) {
+    constructor(tableName, primaryKeyName = "id", initialData = []) {
         this.tableName = tableName;
         this.primaryKeyName = primaryKeyName;
-        initialData.forEach(item => {
+        initialData.forEach((item) => {
             this.data.set(item[primaryKeyName], item);
         });
     }
@@ -50,56 +50,56 @@ class MockDataSource {
         return record;
     }
     async delete(idOrRecord) {
-        const id = typeof idOrRecord === 'string' ? idOrRecord : idOrRecord[this.primaryKeyName];
+        const id = typeof idOrRecord === "string" ? idOrRecord : idOrRecord[this.primaryKeyName];
         this.data.delete(id);
     }
 }
-describe('Table Event Source Functionality', () => {
+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',
+        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' }
-        ]
+            { 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
+        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');
+        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'
+            dataContextId: "test-context",
         };
         const eventRegistry = new event_registry_1.EventRegistry(mockDataContextForRegistry);
-        const mockDataContext = {
+        const _mockDataContext = {
             dataSourceFactory: () => subscribableDataSource,
-            eventRegistry: eventRegistry
+            eventRegistry: eventRegistry,
         };
         // Create table with the subscribable data source
         const metaData = {
             ...testMetadata,
-            name: uniqueTableName
+            name: uniqueTableName,
         };
         const deps = {
             dataSource: subscribableDataSource,
             eventRegistry: eventRegistry,
-            schema: testSchema
+            schema: testSchema,
         };
         table = new table_1.Table(metaData, deps);
         // Subscribe to events to capture them
@@ -107,17 +107,17 @@ describe('Table Event Source Functionality', () => {
             capturedEvents.push(event);
         });
     });
-    describe('Local Operations', () => {
-        it('should mark insert events as local when called from table', async () => {
+    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'
+                op: "insert",
+                source: "local",
             });
         });
-        it('should mark update events as local when called from table', async () => {
+        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
@@ -126,11 +126,11 @@ describe('Table Event Source Functionality', () => {
             expect(capturedEvents).toHaveLength(1);
             expect(capturedEvents[0]).toEqual({
                 dataObject: updatedRecord,
-                op: 'update',
-                source: 'local'
+                op: "update",
+                source: "local",
             });
         });
-        it('should mark delete events as local when called from table', async () => {
+        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
@@ -138,20 +138,20 @@ describe('Table Event Source Functionality', () => {
             expect(capturedEvents).toHaveLength(1);
             expect(capturedEvents[0]).toEqual({
                 dataObject: testRecord,
-                op: 'delete',
-                source: 'local'
+                op: "delete",
+                source: "local",
             });
         });
-        it('should mark save events as local (insert case)', async () => {
+        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'
+                op: "insert",
+                source: "local",
             });
         });
-        it('should mark save events as local (update case)', async () => {
+        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
@@ -160,22 +160,22 @@ describe('Table Event Source Functionality', () => {
             expect(capturedEvents).toHaveLength(1);
             expect(capturedEvents[0]).toEqual({
                 dataObject: updatedRecord,
-                op: 'update',
-                source: 'local'
+                op: "update",
+                source: "local",
             });
         });
     });
-    describe('Remote Operations', () => {
-        it('should mark insert events as remote when called from underlying source', async () => {
+    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'
+                op: "insert",
+                source: "remote",
             });
         });
-        it('should mark update events as remote when called from underlying source', async () => {
+        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
@@ -184,11 +184,11 @@ describe('Table Event Source Functionality', () => {
             expect(capturedEvents).toHaveLength(1);
             expect(capturedEvents[0]).toEqual({
                 dataObject: updatedRecord,
-                op: 'update',
-                source: 'remote'
+                op: "update",
+                source: "remote",
             });
         });
-        it('should mark delete events as remote when called from underlying source', async () => {
+        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
@@ -196,95 +196,85 @@ describe('Table Event Source Functionality', () => {
             expect(capturedEvents).toHaveLength(1);
             expect(capturedEvents[0]).toEqual({
                 dataObject: testRecord,
-                op: 'delete',
-                source: 'remote'
+                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 };
+    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)
-            ]);
+            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');
+            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']);
+            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 };
+        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 };
+            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)
+                table.insert(record3),
             ]);
             expect(capturedEvents).toHaveLength(3);
             // All should be marked as local
-            capturedEvents.forEach(event => {
-                expect(event.source).toBe('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']);
+            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 };
+        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)
-            ]);
+            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');
+            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 };
+        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 };
+            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)
-            ]);
+            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');
+            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 };
+    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
@@ -292,50 +282,50 @@ describe('Table Event Source Functionality', () => {
             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
+            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 };
+        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) {
+            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');
+            expect(capturedEvents[0].source).toBe("remote");
         });
     });
-    describe('Table Without Underlying SubscribableDataSource', () => {
-        it('should work correctly when no underlying SubscribableDataSource exists', async () => {
+    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 plainDataSource = new MockDataSource("PlainTable", "id");
             const mockDataContextForRegistry2 = {
-                dataContextId: 'test-context-2'
+                dataContextId: "test-context-2",
             };
             const eventRegistry2 = new event_registry_1.EventRegistry(mockDataContextForRegistry2);
-            const mockDataContext = {
+            const _mockDataContext = {
                 dataSourceFactory: () => plainDataSource,
-                eventRegistry: eventRegistry2
+                eventRegistry: eventRegistry2,
             };
             const plainTableDeps = {
                 dataSource: plainDataSource,
                 eventRegistry: eventRegistry2,
-                schema: testSchema
+                schema: testSchema,
             };
             const plainTable = new table_1.Table(testMetadata, plainTableDeps);
             const events = [];
-            plainTable.dataChanged.subscribe(event => {
+            plainTable.dataChanged.subscribe((event) => {
                 events.push(event);
             });
             await plainTable.insert(testRecord);
             expect(events).toHaveLength(1);
-            expect(events[0].source).toBe('local');
+            expect(events[0].source).toBe("local");
         });
     });
 });

package/dist/data/orm/table.js

@@ -1,15 +1,18 @@
 "use strict";
+// import { Collection } from "peers-kore";
+// import { injectDB } from "../../common/inject-db";
+// import { singular } from "peers-kore/dist/orm/factory";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = void 0;
 exports.getIconClassName = getIconClassName;
+const lodash_1 = require("lodash");
+const rpc_types_1 = require("../../rpc-types");
+const utils_1 = require("../../utils");
 const data_query_1 = require("./data-query");
 const doc_1 = require("./doc");
+const sql_data_source_1 = require("./sql.data-source");
 const subscribable_data_source_1 = require("./subscribable.data-source");
 const types_1 = require("./types");
-const utils_1 = require("../../utils");
-const rpc_types_1 = require("../../rpc-types");
-const lodash_1 = require("lodash");
-const sql_data_source_1 = require("./sql.data-source");
 class Table {
     tableName;
     primaryKeyName;
@@ -30,7 +33,7 @@ class Table {
         this.tableName = (0, utils_1.getFullTableName)(metaData);
         this.primaryKeyName = metaData.primaryKeyName;
         // Event setup with explicit dependency
-        const eventName = this.tableName + "_DataChanged";
+        const eventName = `${this.tableName}_DataChanged`;
         this.dataChangedEmitter = deps.eventRegistry.getEmitter(eventName);
         this.dataChanged = this.dataChangedEmitter.event;
         if (rpc_types_1.isClient && !(0, rpc_types_1.isSingleProcessClient)()) {
@@ -38,12 +41,12 @@ class Table {
             this.dataChangedEmitter.emit = lodash_1.noop;
         }
         // Validation (works for both patterns since this.metaData is set)
-        const primaryKeyIsValid = this.metaData.fields.find(f => f.name === this.metaData.primaryKeyName);
+        const primaryKeyIsValid = this.metaData.fields.find((f) => f.name === this.metaData.primaryKeyName);
         if (!primaryKeyIsValid) {
             throw new Error(`Table "${this.tableName}", primary key "${this.metaData.primaryKeyName}" is not a valid field name`);
         }
         // Find any underlying SubscribableDataSource to intercept its events
-        let subscribableDataSource = undefined;
+        let subscribableDataSource;
         let _dataSource = this.dataSource;
         while (_dataSource) {
             if (!subscribableDataSource && _dataSource instanceof subscribable_data_source_1.SubscribableDataSource) {
@@ -66,7 +69,7 @@ class Table {
                     this.dataChangedEmitter.emit({
                         dataObject: event.dataObject,
                         op: event.op,
-                        source: 'remote',
+                        source: "remote",
                     });
                 }
             });
@@ -90,25 +93,25 @@ class Table {
         if (useCache && this.cachedRecords[id]) {
             return this.cachedRecords[id];
         }
-        const promise = new Promise(async (resolve, reject) => {
+        const promise = (async () => {
             try {
                 let record;
                 record = await this.dataSource.get(id);
                 if (!record) {
                     cacheTtlMs = 1000; // very short cache ttl for non-existent records
                 }
-                resolve(record);
+                return record;
             }
             catch (err) {
                 cacheTtlMs = 1000; // very short cache ttl on error
-                reject(err);
+                throw err;
             }
             finally {
                 setTimeout(() => {
                     delete this.cachedRecords[id];
                 }, cacheTtlMs);
             }
-        });
+        })();
         if (useCache) {
             this.cachedRecords[id] = promise;
         }
@@ -117,11 +120,9 @@ class Table {
     async list(filter = {}, opts = {}) {
         return this.dataSource.list(filter, opts);
     }
-    ;
     async count(filter = {}) {
         return (0, data_query_1.dataSourceCount)(this.dataSource, filter);
     }
-    ;
     cursor(filter = {}, opts = {}) {
         return (0, data_query_1.dataSourceCursor)(this.dataSource, filter, opts);
     }
@@ -144,12 +145,12 @@ class Table {
             delete this.cachedRecords[recordId];
         }
         const isInsert = !recordId || !(await this.get(recordId));
-        const operation = isInsert ? 'insert' : 'update';
+        const operation = isInsert ? "insert" : "update";
         this.setLocalOperation(recordId, operation);
         let result;
         try {
             // NOTE: done this way to allow individual tables to have custom logic in `save`, `insert`, and `update`
-            //       but this results in a double-read (this method and the data-source method).  
+            //       but this results in a double-read (this method and the data-source method).
             // TODO: try to avoid the double-read, probably by passing the just-read result as `opts.dbData`
             result = await this.dataSource.save(record, opts);
         }
@@ -159,63 +160,63 @@ class Table {
         this.dataChangedEmitter.emit({
             dataObject: result,
             op: operation,
-            source: 'local',
+            source: "local",
         });
         return result;
     }
     async insert(record) {
         const recordId = this.getRecordId(record);
-        this.setLocalOperation(recordId, 'insert');
+        this.setLocalOperation(recordId, "insert");
         let result;
         try {
             result = await this.dataSource.insert(record);
         }
         finally {
-            this.clearLocalOperation(recordId, 'insert');
+            this.clearLocalOperation(recordId, "insert");
         }
         this.dataChangedEmitter.emit({
             dataObject: result,
-            op: 'insert',
-            source: 'local',
+            op: "insert",
+            source: "local",
         });
         return result;
     }
     async update(record) {
         delete this.cachedRecords[record[this.metaData.primaryKeyName]];
         const recordId = this.getRecordId(record);
-        this.setLocalOperation(recordId, 'update');
+        this.setLocalOperation(recordId, "update");
         let result;
         try {
             result = await this.dataSource.update(record);
         }
         finally {
-            this.clearLocalOperation(recordId, 'update');
+            this.clearLocalOperation(recordId, "update");
         }
         this.dataChangedEmitter.emit({
             dataObject: result,
-            op: 'update',
-            source: 'local',
+            op: "update",
+            source: "local",
         });
         return result;
     }
     async delete(idOrRecord) {
-        const primaryKey = typeof idOrRecord === 'string' ? idOrRecord : idOrRecord[this.metaData.primaryKeyName];
-        const existingRecord = typeof idOrRecord === 'object' ? idOrRecord : await this.get(primaryKey);
+        const primaryKey = typeof idOrRecord === "string" ? idOrRecord : idOrRecord[this.metaData.primaryKeyName];
+        const existingRecord = typeof idOrRecord === "object" ? idOrRecord : await this.get(primaryKey);
         delete this.cachedRecords[primaryKey];
         if (!existingRecord) {
             return; // nothing to delete
         }
-        this.setLocalOperation(primaryKey, 'delete');
+        this.setLocalOperation(primaryKey, "delete");
         try {
             await this.dataSource.delete(idOrRecord);
         }
         finally {
-            this.clearLocalOperation(primaryKey, 'delete');
+            this.clearLocalOperation(primaryKey, "delete");
         }
         this.dataChangedEmitter.emit({
             dataObject: existingRecord,
-            op: 'delete',
-            source: 'local',
+            op: "delete",
+            source: "local",
         });
     }
     initRecord(data = {}) {
@@ -225,7 +226,7 @@ class Table {
             if (this.codeSchema?.shape?.[field.name]) {
                 const codeValue = this.codeSchema.shape[field.name].safeParse(data[field.name]);
                 if (codeValue.success) {
-                    // @ts-ignore
+                    // @ts-expect-error
                     defaults[field.name] = codeValue.data;
                     continue;
                 }
@@ -234,7 +235,7 @@ class Table {
             const zodField = this.schema.shape[field.name];
             const value = zodField.safeParse(data[field.name]);
             if (value.success) {
-                // @ts-ignore
+                // @ts-expect-error
                 defaults[field.name] = value.data;
             }
         }
@@ -252,5 +253,5 @@ class Table {
 }
 exports.Table = Table;
 function getIconClassName(table) {
-    return table.metaData.iconClassName ?? 'bi bi-question';
+    return table.metaData.iconClassName ?? "bi bi-question";
 }

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

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-import { IField } from '../../types/field-type';
+import { z } from "zod";
+import { type IField } from "../../types/field-type";
 export interface ITableMetaData {
     tableId?: string;
     name: string;
@@ -9,7 +9,7 @@ export interface ITableMetaData {
     indexes?: {
         fields: (string | {
             name: string;
-            order: 'ASC' | 'DESC';
+            order: "ASC" | "DESC";
         })[];
         unique?: true;
     }[];