@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/messages.js

@@ -4,41 +4,56 @@ exports.messageSchema = void 0;
 exports.Messages = Messages;
 exports.sendMessage = sendMessage;
 exports.getThreadVars = getThreadVars;
-const types_1 = require("./orm/types");
-const users_1 = require("./users");
-const groups_1 = require("./groups");
-const channels_1 = require("./channels");
-const workflow_runs_1 = require("./workflow-runs");
-const utils_1 = require("../utils");
 const zod_1 = require("zod");
-const zod_types_1 = require("../types/zod-types");
 const user_context_singleton_1 = require("../context/user-context-singleton");
+const zod_types_1 = require("../types/zod-types");
+const utils_1 = require("../utils");
+const channels_1 = require("./channels");
+const groups_1 = require("./groups");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
+const users_1 = require("./users");
+const workflow_runs_1 = require("./workflow-runs");
 exports.messageSchema = zod_1.z.object({
     messageId: zod_types_1.zodPeerId,
-    channelId: zod_types_1.zodPeerId.describe('The id of the channel this message entry belongs to'),
-    userId: zod_types_1.zodPeerId.describe('The id of the user who created this message entry'),
-    messageParentId: zod_types_1.zodPeerId.optional().describe('The id of the parent message entry if this is part of a thread'),
-    assistantId: zod_types_1.zodPeerId.optional().describe(`The id of the user's assistant that created this message entry operating on behalf of the user`),
-    message: zod_1.z.string().describe('The markdown content of this message entry'),
+    channelId: zod_types_1.zodPeerId.describe("The id of the channel this message entry belongs to"),
+    userId: zod_types_1.zodPeerId.describe("The id of the user who created this message entry"),
+    messageParentId: zod_types_1.zodPeerId
+        .optional()
+        .describe("The id of the parent message entry if this is part of a thread"),
+    assistantId: zod_types_1.zodPeerId
+        .optional()
+        .describe(`The id of the user's assistant that created this message entry operating on behalf of the user`),
+    message: zod_1.z.string().describe("The markdown content of this message entry"),
     createdAt: zod_1.z.date(),
-    editedAt: zod_1.z.date().optional().describe('The time this message entry was last edited, if it was edited'),
-    fileIds: zod_types_1.zodPeerId.array().optional().describe('The ids of files attached to this message entry'),
-    vars: zod_types_1.zodAnyObject.optional().describe('The variables that are associated with this message entry'),
+    editedAt: zod_1.z
+        .date()
+        .optional()
+        .describe("The time this message entry was last edited, if it was edited"),
+    fileIds: zod_types_1.zodPeerId.array().optional().describe("The ids of files attached to this message entry"),
+    vars: zod_types_1.zodAnyObject
+        .optional()
+        .describe("The variables that are associated with this message entry"),
 });
 const metaData = {
-    name: 'Messages',
-    description: 'Messages (chat entries) in a channel',
-    primaryKeyName: 'messageId',
+    name: "Messages",
+    description: "Messages (chat entries) in a channel",
+    primaryKeyName: "messageId",
     fields: (0, types_1.schemaToFields)(exports.messageSchema),
     indexes: [
-        { fields: ['channelId'] },
-        { fields: ['messageParentId'] },
-        { fields: ['userId'] },
-        { fields: ['assistantId'] },
-        { fields: ['channelId', { name: 'createdAt', order: 'DESC' }, { name: 'messageId', order: 'DESC' }] },
-        { fields: ['messageParentId', 'createdAt', 'messageId'] },
-    ]
+        { fields: ["channelId"] },
+        { fields: ["messageParentId"] },
+        { fields: ["userId"] },
+        { fields: ["assistantId"] },
+        {
+            fields: [
+                "channelId",
+                { name: "createdAt", order: "DESC" },
+                { name: "messageId", order: "DESC" },
+            ],
+        },
+        { fields: ["messageParentId", "createdAt", "messageId"] },
+    ],
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.messageSchema);
 function Messages(dataContext) {
@@ -84,15 +99,13 @@ async function sendMessage(args) {
     return message;
 }
 async function getThreadVars(message) {
-    const $or = [
-        { messageId: message.messageId },
-    ];
+    const $or = [{ messageId: message.messageId }];
     if (message.messageParentId) {
         $or.push({ messageId: message.messageParentId });
     }
     const threadMessages = await Messages().list({
-        $or
-    }, { sortBy: ['createdAt'] });
+        $or,
+    }, { sortBy: ["createdAt"] });
     // Note that sort order is very important so that newer var values overwrite older ones
     const vars = threadMessages.reduce((acc, message) => {
         Object.assign(acc, message.vars ?? {});

package/dist/data/orm/client-proxy.data-source.d.ts

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import { DataFilter, ICursorIterable, IDataQueryParams, IDataSource, ISaveOptions } from "./data-query";
-import { ITableMetaData } from "./types";
+import type { z } from "zod";
+import { type DataFilter, type ICursorIterable, type IDataQueryParams, type IDataSource, type ISaveOptions } from "./data-query";
+import { type ITableMetaData } from "./types";
 export declare class ClientProxyDataSource<T extends {
     [key: string]: any;
 }> implements IDataSource<T> {
@@ -9,7 +9,7 @@ export declare class ClientProxyDataSource<T extends {
     readonly dataContextId: string;
     readonly tableName: string;
     readonly primaryKeyName: string;
-    constructor(metaData: ITableMetaData, schema: z.AnyZodObject, dataContextId: string);
+    constructor(metaData: ITableMetaData, schema: z.AnyZodObject | undefined, dataContextId: string);
     get(id: string, opts?: {
         useCache?: boolean;
         cacheTtlMs?: number;

package/dist/data/orm/client-proxy.data-source.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientProxyDataSource = void 0;
 const rpc_types_1 = require("../../rpc-types");
+const utils_1 = require("../../utils");
 const data_query_1 = require("./data-query");
 const types_1 = require("./types");
-const utils_1 = require("../../utils");
 class ClientProxyDataSource {
     metaData;
     schema;
@@ -17,39 +17,37 @@ class ClientProxyDataSource {
         this.dataContextId = dataContextId;
         this.tableName = (0, utils_1.getFullTableName)(metaData);
         this.primaryKeyName = metaData.primaryKeyName;
-        const primaryKeyIsValid = metaData.fields.find(f => f.name === metaData.primaryKeyName);
+        const primaryKeyIsValid = metaData.fields.find((f) => f.name === metaData.primaryKeyName);
         if (!primaryKeyIsValid) {
             throw new Error(`Table "${this.tableName}", primary key "${metaData.primaryKeyName}" is not a valid field name`);
         }
     }
     async get(id, opts = {}) {
-        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, 'get', id, opts);
+        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, "get", id, opts);
     }
     async list(filter = {}, opts = {}) {
-        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, 'list', filter, opts);
+        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, "list", filter, opts);
     }
-    ;
     async count(filter = {}) {
-        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, 'count', filter);
+        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, "count", filter);
     }
-    ;
     cursor(filter = {}, opts = {}) {
         return (0, data_query_1.dataSourceCursor)(this, filter, opts);
     }
     async findOne(filter = {}, opts) {
-        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, 'findOne', filter, opts);
+        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, "findOne", filter, opts);
     }
     async save(record, opts) {
-        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, 'save', record, opts);
+        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, "save", record, opts);
     }
     async insert(record) {
-        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, 'insert', record);
+        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, "insert", record);
     }
     async update(record) {
-        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, 'update', record);
+        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, "update", record);
     }
     async delete(idOrRecord) {
-        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, 'delete', idOrRecord);
+        return rpc_types_1.rpcServerCalls.tableMethodCall(this.dataContextId, this.tableName, "delete", idOrRecord);
     }
 }
 exports.ClientProxyDataSource = ClientProxyDataSource;

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

@@ -1,4 +1,4 @@
-import { ICursorIterable, DataFilter, IDataQueryParams } from './data-query';
+import { type DataFilter, type ICursorIterable, type IDataQueryParams } from "./data-query";
 export declare class Cursor<T> implements ICursorIterable<T> {
     private _cursor;
     constructor(_cursor: ICursorIterable<T>);

package/dist/data/orm/cursor.js

@@ -28,13 +28,13 @@ class Cursor {
         return new Cursor((0, multi_cursors_1.queryMerge)(dataSources, filter, opts));
     }
     static union(...cursors) {
-        const unwrappedCursors = cursors.map(c => c instanceof Cursor ? c._cursor : c);
+        const unwrappedCursors = cursors.map((c) => (c instanceof Cursor ? c._cursor : c));
         return new Cursor((0, multi_cursors_1.cursorUnion)(unwrappedCursors));
     }
     // Instance methods
     union(...others) {
         const allCursors = [this, ...others];
-        const unwrappedCursors = allCursors.map(c => c instanceof Cursor ? c._cursor : c);
+        const unwrappedCursors = allCursors.map((c) => (c instanceof Cursor ? c._cursor : c));
         return new Cursor((0, multi_cursors_1.cursorUnion)(unwrappedCursors));
     }
     map(mapFn) {

package/dist/data/orm/cursor.test.js

@@ -19,9 +19,9 @@ function createMockCursor(items) {
     };
     return (0, data_query_1.iterableCursor)(cursor);
 }
-describe('Cursor', () => {
-    describe('basic functionality', () => {
-        it('should wrap an ICursorIterable and implement the interface', async () => {
+describe("Cursor", () => {
+    describe("basic functionality", () => {
+        it("should wrap an ICursorIterable and implement the interface", async () => {
             const mockCursor = createMockCursor([1, 2, 3]);
             const cursor = new cursor_1.Cursor(mockCursor);
             const results = [];
@@ -30,16 +30,16 @@ describe('Cursor', () => {
             }
             expect(results).toEqual([1, 2, 3]);
         });
-        it('should support manual next() calls', async () => {
-            const mockCursor = createMockCursor(['a', 'b', 'c']);
+        it("should support manual next() calls", async () => {
+            const mockCursor = createMockCursor(["a", "b", "c"]);
             const cursor = new cursor_1.Cursor(mockCursor);
             const results = [];
             while (await cursor.next()) {
                 results.push(cursor.value);
             }
-            expect(results).toEqual(['a', 'b', 'c']);
+            expect(results).toEqual(["a", "b", "c"]);
         });
-        it('should maintain cursor.value correctly', async () => {
+        it("should maintain cursor.value correctly", async () => {
             const mockCursor = createMockCursor([10, 20]);
             const cursor = new cursor_1.Cursor(mockCursor);
             expect(cursor.value).toBeNull();
@@ -52,8 +52,8 @@ describe('Cursor', () => {
             expect(cursor.value).toBeNull();
         });
     });
-    describe('static factory methods', () => {
-        it('should create cursor from ICursorIterable using from()', async () => {
+    describe("static factory methods", () => {
+        it("should create cursor from ICursorIterable using from()", async () => {
             const mockCursor = createMockCursor([1, 2, 3]);
             const cursor = cursor_1.Cursor.from(mockCursor);
             const results = [];
@@ -62,7 +62,7 @@ describe('Cursor', () => {
             }
             expect(results).toEqual([1, 2, 3]);
         });
-        it('should create union cursor using static union()', async () => {
+        it("should create union cursor using static union()", async () => {
             const cursor1 = createMockCursor([1, 2]);
             const cursor2 = createMockCursor([3, 4]);
             const cursor3 = createMockCursor([5, 6]);
@@ -73,7 +73,7 @@ describe('Cursor', () => {
             }
             expect(results).toEqual([1, 2, 3, 4, 5, 6]);
         });
-        it('should handle mix of Cursor and ICursorIterable in static union()', async () => {
+        it("should handle mix of Cursor and ICursorIterable in static union()", async () => {
             const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
             const cursor2 = createMockCursor([3, 4]);
             const unionCursor = cursor_1.Cursor.union(cursor1, cursor2);
@@ -84,8 +84,8 @@ describe('Cursor', () => {
             expect(results).toEqual([1, 2, 3, 4]);
         });
     });
-    describe('instance methods', () => {
-        it('should create union cursor using instance union()', async () => {
+    describe("instance methods", () => {
+        it("should create union cursor using instance union()", async () => {
             const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
             const cursor2 = createMockCursor([3, 4]);
             const cursor3 = new cursor_1.Cursor(createMockCursor([5, 6]));
@@ -96,7 +96,7 @@ describe('Cursor', () => {
             }
             expect(results).toEqual([1, 2, 3, 4, 5, 6]);
         });
-        it('should map cursor values using instance map()', async () => {
+        it("should map cursor values using instance map()", async () => {
             const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
             const mappedCursor = cursor.map((x) => x * 2);
             const results = [];
@@ -105,36 +105,36 @@ describe('Cursor', () => {
             }
             expect(results).toEqual([2, 4, 6, 8, 10]);
         });
-        it('should support async mapping functions', async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor(['hello', 'world']));
+        it("should support async mapping functions", async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor(["hello", "world"]));
             const mappedCursor = cursor.map(async (x) => {
-                await new Promise(resolve => setTimeout(resolve, 1));
+                await new Promise((resolve) => setTimeout(resolve, 1));
                 return x.toUpperCase();
             });
             const results = [];
             for await (const item of mappedCursor) {
                 results.push(item);
             }
-            expect(results).toEqual(['HELLO', 'WORLD']);
+            expect(results).toEqual(["HELLO", "WORLD"]);
         });
-        it('should support method chaining', async () => {
+        it("should support method chaining", async () => {
             const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
             const cursor2 = createMockCursor([3, 4]);
             const result = cursor1
                 .union(cursor2)
-                .map(x => x * 10)
-                .map(x => `num: ${x}`);
+                .map((x) => x * 10)
+                .map((x) => `num: ${x}`);
             const results = [];
             for await (const item of result) {
                 results.push(item);
             }
-            expect(results).toEqual(['num: 10', 'num: 20', 'num: 30', 'num: 40']);
+            expect(results).toEqual(["num: 10", "num: 20", "num: 30", "num: 40"]);
         });
-        it('should handle empty cursors in operations', async () => {
+        it("should handle empty cursors in operations", async () => {
             const cursor1 = new cursor_1.Cursor(createMockCursor([]));
             const cursor2 = createMockCursor([1, 2]);
             const unionCursor = cursor1.union(cursor2);
-            const mappedCursor = unionCursor.map(x => x * 2);
+            const mappedCursor = unionCursor.map((x) => x * 2);
             const results = [];
             for await (const item of mappedCursor) {
                 results.push(item);
@@ -142,17 +142,17 @@ describe('Cursor', () => {
             expect(results).toEqual([2, 4]);
         });
     });
-    describe('error handling', () => {
-        it('should propagate skipPast errors from map()', async () => {
+    describe("error handling", () => {
+        it("should propagate skipPast errors from map()", async () => {
             const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
-            const mappedCursor = cursor.map(x => x * 2);
-            await expect(mappedCursor.next(4)).rejects.toThrow('skipPast is not supported for cursorMap since the mapped cursor has a different type than the source cursor');
+            const mappedCursor = cursor.map((x) => x * 2);
+            await expect(mappedCursor.next(4)).rejects.toThrow("skipPast is not supported for cursorMap since the mapped cursor has a different type than the source cursor");
         });
-        it('should propagate async errors from mapping functions', async () => {
+        it("should propagate async errors from mapping functions", async () => {
             const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
             const mappedCursor = cursor.map(async (x) => {
                 if (x === 2) {
-                    throw new Error('Test error');
+                    throw new Error("Test error");
                 }
                 return x * 2;
             });
@@ -165,87 +165,86 @@ describe('Cursor', () => {
             }
             catch (error) {
                 errorCaught = true;
-                expect(error.message).toBe('Test error');
+                expect(error.message).toBe("Test error");
             }
             expect(errorCaught).toBe(true);
             expect(results).toEqual([2]); // Only first item before error
         });
     });
-    describe('static factory methods for data sources', () => {
-        it('should create cursor from single dataSource using fromDataSource', async () => {
+    describe("static factory methods for data sources", () => {
+        it("should create cursor from single dataSource using fromDataSource", async () => {
             const dataSource = (0, factory_1.arrayAsTable)([
-                { id: 1, name: 'Alice' },
-                { id: 2, name: 'Bob' },
-                { id: 3, name: 'Charlie' },
-            ], { name: 'users' });
-            const cursor = cursor_1.Cursor.fromDataSource(dataSource, {}, { sortBy: ['name'] });
+                { id: 1, name: "Alice" },
+                { id: 2, name: "Bob" },
+                { id: 3, name: "Charlie" },
+            ], { name: "users" });
+            const cursor = cursor_1.Cursor.fromDataSource(dataSource, {}, { sortBy: ["name"] });
             const results = [];
             for await (const item of cursor) {
                 results.push(item);
             }
-            expect(results.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie']);
+            expect(results.map((r) => r.name)).toEqual(["Alice", "Bob", "Charlie"]);
         });
-        it('should create cursor from multiple dataSources using fromDataSources', async () => {
+        it("should create cursor from multiple dataSources using fromDataSources", async () => {
             const dataSource1 = (0, factory_1.arrayAsTable)([
-                { id: 1, name: 'Alice' },
-                { id: 3, name: 'Charlie' },
-            ], { name: 'users1' });
+                { id: 1, name: "Alice" },
+                { id: 3, name: "Charlie" },
+            ], { name: "users1" });
             const dataSource2 = (0, factory_1.arrayAsTable)([
-                { id: 2, name: 'Bob' },
-                { id: 4, name: 'David' },
-            ], { name: 'users2' });
+                { id: 2, name: "Bob" },
+                { id: 4, name: "David" },
+            ], { name: "users2" });
             const cursor = cursor_1.Cursor.fromDataSources([dataSource1, dataSource2]);
             const results = [];
             for await (const item of cursor) {
                 results.push(item);
             }
-            expect(results.map(r => r.id)).toEqual([1, 2, 3, 4]);
+            expect(results.map((r) => r.id)).toEqual([1, 2, 3, 4]);
         });
-        it('should support filters and options with fromDataSource', async () => {
+        it("should support filters and options with fromDataSource", async () => {
             const dataSource = (0, factory_1.arrayAsTable)([
-                { id: 1, name: 'Alice', age: 25 },
-                { id: 2, name: 'Bob', age: 30 },
-                { id: 3, name: 'Charlie', age: 35 },
-            ], { name: 'users' });
-            const cursor = cursor_1.Cursor.fromDataSource(dataSource, { age: { $gte: 30 } }, { sortBy: ['name'] });
+                { id: 1, name: "Alice", age: 25 },
+                { id: 2, name: "Bob", age: 30 },
+                { id: 3, name: "Charlie", age: 35 },
+            ], { name: "users" });
+            const cursor = cursor_1.Cursor.fromDataSource(dataSource, { age: { $gte: 30 } }, { sortBy: ["name"] });
             const results = [];
             for await (const item of cursor) {
                 results.push(item);
             }
             // Should only get Bob and Charlie (age >= 30), sorted by name
-            expect(results.map(r => r.name)).toEqual(['Bob', 'Charlie']);
+            expect(results.map((r) => r.name)).toEqual(["Bob", "Charlie"]);
         });
-        it('should support filters and options with fromDataSources', async () => {
+        it("should support filters and options with fromDataSources", async () => {
             const dataSource1 = (0, factory_1.arrayAsTable)([
-                { id: 1, name: 'Alice', age: 25 },
-                { id: 2, name: 'Bob', age: 30 },
-            ], { name: 'users1' });
+                { id: 1, name: "Alice", age: 25 },
+                { id: 2, name: "Bob", age: 30 },
+            ], { name: "users1" });
             const dataSource2 = (0, factory_1.arrayAsTable)([
-                { id: 3, name: 'Charlie', age: 35 },
-                { id: 4, name: 'David', age: 20 },
-            ], { name: 'users2' });
-            const cursor = cursor_1.Cursor.fromDataSources([dataSource1, dataSource2], { age: { $gte: 25 } }, { sortBy: ['name'] });
+                { id: 3, name: "Charlie", age: 35 },
+                { id: 4, name: "David", age: 20 },
+            ], { name: "users2" });
+            const cursor = cursor_1.Cursor.fromDataSources([dataSource1, dataSource2], { age: { $gte: 25 } }, { sortBy: ["name"] });
             const results = [];
             for await (const item of cursor) {
                 results.push(item);
             }
             // Should get Alice, Bob, Charlie (age >= 25), sorted by name
-            expect(results.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie']);
+            expect(results.map((r) => r.name)).toEqual(["Alice", "Bob", "Charlie"]);
         });
-        it('should work with method chaining after fromDataSource', async () => {
+        it("should work with method chaining after fromDataSource", async () => {
             const dataSource = (0, factory_1.arrayAsTable)([
-                { id: 1, name: 'Alice' },
-                { id: 2, name: 'Bob' },
-            ], { name: 'users' });
-            const cursor = cursor_1.Cursor.fromDataSource(dataSource)
-                .map(item => item.name.toUpperCase());
+                { id: 1, name: "Alice" },
+                { id: 2, name: "Bob" },
+            ], { name: "users" });
+            const cursor = cursor_1.Cursor.fromDataSource(dataSource).map((item) => item.name.toUpperCase());
             const results = [];
             for await (const item of cursor) {
                 results.push(item);
             }
-            expect(results).toEqual(['ALICE', 'BOB']);
+            expect(results).toEqual(["ALICE", "BOB"]);
         });
-        it('should filter cursor values using instance filter()', async () => {
+        it("should filter cursor values using instance filter()", async () => {
             const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]));
             const filteredCursor = cursor.filter((x) => x % 3 === 0);
             const results = [];
@@ -254,57 +253,57 @@ describe('Cursor', () => {
             }
             expect(results).toEqual([3, 6, 9]);
         });
-        it('should support async filter functions', async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor(['apple', 'banana', 'cherry', 'date', 'elderberry']));
+        it("should support async filter functions", async () => {
+            const cursor = new cursor_1.Cursor(createMockCursor(["apple", "banana", "cherry", "date", "elderberry"]));
             const filteredCursor = cursor.filter(async (x) => {
-                await new Promise(resolve => setTimeout(resolve, 1));
-                return x.startsWith('a') || x.startsWith('e');
+                await new Promise((resolve) => setTimeout(resolve, 1));
+                return x.startsWith("a") || x.startsWith("e");
             });
             const results = [];
             for await (const item of filteredCursor) {
                 results.push(item);
             }
-            expect(results).toEqual(['apple', 'elderberry']);
+            expect(results).toEqual(["apple", "elderberry"]);
         });
-        it('should support method chaining with filter', async () => {
+        it("should support method chaining with filter", async () => {
             const cursor = new cursor_1.Cursor(createMockCursor([
-                { id: 1, name: 'Alice', age: 25 },
-                { id: 2, name: 'Bob', age: 30 },
-                { id: 3, name: 'Charlie', age: 35 },
-                { id: 4, name: 'David', age: 20 }
+                { id: 1, name: "Alice", age: 25 },
+                { id: 2, name: "Bob", age: 30 },
+                { id: 3, name: "Charlie", age: 35 },
+                { id: 4, name: "David", age: 20 },
             ]));
             const result = cursor
-                .filter(person => person.age >= 25)
-                .map(person => person.name.toUpperCase())
-                .filter(name => name.includes('A'));
+                .filter((person) => person.age >= 25)
+                .map((person) => person.name.toUpperCase())
+                .filter((name) => name.includes("A"));
             const results = [];
             for await (const item of result) {
                 results.push(item);
             }
-            expect(results).toEqual(['ALICE', 'CHARLIE']);
+            expect(results).toEqual(["ALICE", "CHARLIE"]);
         });
-        it('should handle empty results after filtering', async () => {
+        it("should handle empty results after filtering", async () => {
             const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
-            const filteredCursor = cursor.filter(x => x > 10);
+            const filteredCursor = cursor.filter((x) => x > 10);
             const results = [];
             for await (const item of filteredCursor) {
                 results.push(item);
             }
             expect(results).toEqual([]);
         });
-        it('should propagate skipPast errors from filter()', async () => {
+        it("should propagate skipPast errors from filter()", async () => {
             const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
-            const filteredCursor = cursor.filter(x => x > 2);
-            await expect(filteredCursor.next(3)).rejects.toThrow('skipPast is not supported for cursorFilter since filtering changes the cursor iteration order');
+            const filteredCursor = cursor.filter((x) => x > 2);
+            await expect(filteredCursor.next(3)).rejects.toThrow("skipPast is not supported for cursorFilter since filtering changes the cursor iteration order");
         });
-        it('should support complex method chaining with union, filter, and map', async () => {
+        it("should support complex method chaining with union, filter, and map", async () => {
             const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
             const cursor2 = createMockCursor([4, 5, 6]);
             const cursor3 = createMockCursor([7, 8, 9]);
             const result = cursor1
                 .union(cursor2, cursor3)
-                .filter(x => x % 2 === 1) // odd numbers
-                .map(x => x * 10);
+                .filter((x) => x % 2 === 1) // odd numbers
+                .map((x) => x * 10);
             const results = [];
             for await (const item of result) {
                 results.push(item);

package/dist/data/orm/data-query.d.ts

@@ -44,7 +44,7 @@ export interface IDataQueryParams<T extends Record<string, any>> {
 }
 export declare class DataQuery<T extends Record<string, any>> {
     readonly table: ITable<T>;
-    constructor(table: ITable<T>, { page, pageSize, sortBy, filter, textSearch, textSearchExact, }?: IDataQueryParams<T>);
+    constructor(table: ITable<T>, { page, pageSize, sortBy, filter, textSearch, textSearchExact }?: IDataQueryParams<T>);
     page?: number;
     pageSize?: number;
     sortBy?: SortBy<T>;
@@ -77,9 +77,9 @@ export type SortBy<T extends {
     [key: string]: any;
 }> = (keyof T extends string | number ? keyof T | `-${keyof T}` : never)[];
 export type DataFieldScalar = boolean | number | string | Date | null;
-export type DataFilterValueOperator = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$exists' | '$matchWords' | '$substr' | '$expr' | '$in';
+export type DataFilterValueOperator = "$eq" | "$ne" | "$gt" | "$gte" | "$lt" | "$lte" | "$exists" | "$matchWords" | "$substr" | "$expr" | "$in";
 export type DataFilterValue = DataFieldScalar | DataFieldScalar[] | {
-    [key in Exclude<DataFilterValueOperator, '$in'>]?: DataFieldScalar;
+    [key in Exclude<DataFilterValueOperator, "$in">]?: DataFieldScalar;
 } | {
     $nin: DataFieldScalar[];
 } | {