@peers-app/peers-sdk 0.1.4

package/dist/data/knowledge/knowledge-links.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeLinks = KnowledgeLinks;
+const zod_1 = require("zod");
+const types_1 = require("../orm/types");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+const zod_types_1 = require("../../types/zod-types");
+const knowledgeLinkSchema = zod_1.z.object({
+    knowledgeLinkId: zod_types_1.zodPeerId,
+    subjectValueId: zod_types_1.zodPeerId.describe('The knowledge entry that is the subject of the link'),
+    predicateId: zod_types_1.zodPeerId.describe('The predicate of the knowledge link'),
+    predicateValue: zod_1.z.any().describe('The value of the predicate'),
+    objectValueId: zod_types_1.zodPeerId.optional().describe('The knowledge entry that is the object of the link'),
+});
+const metaData = {
+    name: 'KnowledgeLinks',
+    description: "The knowledge links in the system",
+    primaryKeyName: 'knowledgeLinkId',
+    fields: (0, types_1.schemaToFields)(knowledgeLinkSchema),
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, knowledgeLinkSchema);
+function KnowledgeLinks(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, knowledgeLinkSchema);
+}

package/dist/data/knowledge/knowledge-values.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import type { DataContext } from "../../context/data-context";
+export declare const knowledgeValueSchema: z.ZodObject<{
+    knowledgeValueId: z.ZodEffects<z.ZodString, string, string>;
+    peerTypeId: z.ZodEffects<z.ZodString, string, string>;
+    value: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+    name: z.ZodString;
+    lastModified: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    value: {} & {
+        [k: string]: any;
+    };
+    knowledgeValueId: string;
+    peerTypeId: string;
+    lastModified?: Date | undefined;
+}, {
+    name: string;
+    value: {} & {
+        [k: string]: any;
+    };
+    knowledgeValueId: string;
+    peerTypeId: string;
+    lastModified?: Date | undefined;
+}>;
+export type IKnowledgeValue = z.infer<typeof knowledgeValueSchema>;
+export declare function KnowledgeValues(dataContext?: DataContext): import("../orm").Table<{
+    name: string;
+    value: {} & {
+        [k: string]: any;
+    };
+    knowledgeValueId: string;
+    peerTypeId: string;
+    lastModified?: Date | undefined;
+}>;

package/dist/data/knowledge/knowledge-values.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.knowledgeValueSchema = void 0;
+exports.KnowledgeValues = KnowledgeValues;
+const zod_1 = require("zod");
+const types_1 = require("../orm/types");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+const zod_types_1 = require("../../types/zod-types");
+exports.knowledgeValueSchema = zod_1.z.object({
+    knowledgeValueId: zod_types_1.zodPeerId,
+    peerTypeId: zod_types_1.zodPeerId.describe('The id of the peer type definition of the knowledge value.'),
+    value: zod_types_1.zodAnyObject.describe('The knowledge value.  It must conform to the value type schema'),
+    // For several reasons (mostly UI and query related) it's useful to have an explicit, top-level name field for everything.  
+    // A disadvantage is that this can be redundant with the name field of the value type (if it exists).
+    // An advantage is this gives us names for simple values
+    // Something weird is names for knowledge values of type `none`.  But a knowledge value of type `none` is weird by itself. (what is it?)
+    name: zod_1.z.string().describe('The name of the knowledge value.'),
+    lastModified: zod_1.z.date().optional().describe('The last time the knowledge value was modified.'),
+});
+const metaData = {
+    name: 'KnowledgeValues',
+    description: "The knowledge values in the system",
+    primaryKeyName: 'knowledgeValueId',
+    fields: (0, types_1.schemaToFields)(exports.knowledgeValueSchema),
+    indexes: [
+        { fields: ['peerTypeId'] },
+        { fields: ['name'] },
+        { fields: ['lastModified'] },
+    ],
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.knowledgeValueSchema);
+function KnowledgeValues(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.knowledgeValueSchema);
+}

package/dist/data/knowledge/peer-types.d.ts

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import type { DataContext } from "../../context/data-context";
+declare const valueTypeSchema: z.ZodObject<{
+    peerTypeId: z.ZodEffects<z.ZodString, string, string>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    schema: z.ZodObject<{
+        type: z.ZodNativeEnum<typeof import("../tools").IOSchemaType>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodNativeEnum<typeof import("../..").FieldType>;
+            defaultValue: z.ZodOptional<z.ZodAny>;
+            optional: z.ZodOptional<z.ZodBoolean>;
+            isArray: z.ZodOptional<z.ZodBoolean>;
+            subType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }, {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: import("../tools").IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    }, {
+        type: import("../tools").IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    }>;
+    iconClass: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    schema: {
+        type: import("../tools").IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    };
+    peerTypeId: string;
+    description?: string | undefined;
+    iconClass?: string | undefined;
+}, {
+    name: string;
+    schema: {
+        type: import("../tools").IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    };
+    peerTypeId: string;
+    description?: string | undefined;
+    iconClass?: string | undefined;
+}>;
+export type IPeerType = z.infer<typeof valueTypeSchema>;
+export declare function PeerTypes(dataContext?: DataContext): import("../orm").Table<{
+    name: string;
+    schema: {
+        type: import("../tools").IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    };
+    peerTypeId: string;
+    description?: string | undefined;
+    iconClass?: string | undefined;
+}>;
+export {};

package/dist/data/knowledge/peer-types.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerTypes = PeerTypes;
+const zod_1 = require("zod");
+const types_1 = require("../orm/types");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+const zod_types_1 = require("../../types/zod-types");
+const tools_1 = require("../tools");
+const valueTypeSchema = zod_1.z.object({
+    peerTypeId: zod_types_1.zodPeerId,
+    name: zod_1.z.string().describe('The name of the peer type'),
+    description: zod_1.z.string().optional().describe('The description of the peer type'),
+    schema: tools_1.ioSchema.describe('The schema of the peer type'),
+    iconClass: zod_1.z.string().optional().describe('The icon class for the peer type'),
+});
+const metaData = {
+    name: 'PeerTypes',
+    description: "The peer types in the system",
+    primaryKeyName: 'peerTypeId',
+    iconClassName: 'bi bi-code-square',
+    fields: (0, types_1.schemaToFields)(valueTypeSchema),
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, valueTypeSchema);
+function PeerTypes(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, valueTypeSchema);
+}

package/dist/data/knowledge/predicates.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { DataContext } from "../../context/data-context";
+declare const predicateSchema: z.ZodObject<{
+    predicateId: z.ZodEffects<z.ZodString, string, string>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    peerTypeId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    allowedSubjectValueTypes: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    allowedObjectValueTypes: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    predicateId: string;
+    description?: string | undefined;
+    peerTypeId?: string | undefined;
+    allowedSubjectValueTypes?: string[] | undefined;
+    allowedObjectValueTypes?: string[] | undefined;
+}, {
+    name: string;
+    predicateId: string;
+    description?: string | undefined;
+    peerTypeId?: string | undefined;
+    allowedSubjectValueTypes?: string[] | undefined;
+    allowedObjectValueTypes?: string[] | undefined;
+}>;
+export type IPredicate = z.infer<typeof predicateSchema>;
+export declare function Predicates(dataContext?: DataContext): import("../orm").Table<{
+    name: string;
+    predicateId: string;
+    description?: string | undefined;
+    peerTypeId?: string | undefined;
+    allowedSubjectValueTypes?: string[] | undefined;
+    allowedObjectValueTypes?: string[] | undefined;
+}>;
+export {};

package/dist/data/knowledge/predicates.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Predicates = Predicates;
+const zod_1 = require("zod");
+const types_1 = require("../orm/types");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+const zod_types_1 = require("../../types/zod-types");
+const predicateSchema = zod_1.z.object({
+    predicateId: zod_types_1.zodPeerId,
+    name: zod_1.z.string().describe('The name of the predicate'),
+    description: zod_1.z.string().optional().describe('The description of the predicate'),
+    peerTypeId: zod_types_1.zodPeerId.optional().describe('The id of the value type to be included with the predicate'),
+    allowedSubjectValueTypes: zod_types_1.zodPeerId.array().optional().describe('The ids of the types that are allowed types of the subject of the predicate value.'),
+    allowedObjectValueTypes: zod_types_1.zodPeerId.array().optional().describe('The ids of the types that are allowed types of the object of the predicate value.'),
+});
+const metaData = {
+    name: 'Predicates',
+    description: "The the predicates in the system",
+    primaryKeyName: 'predicateId',
+    fields: (0, types_1.schemaToFields)(predicateSchema),
+    iconClassName: 'bi bi-node-plus-fill',
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, predicateSchema);
+function Predicates(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, predicateSchema);
+}

package/dist/data/messages.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { DataContext } from "../context/data-context";
+export declare const messageSchema: z.ZodObject<{
+    messageId: z.ZodEffects<z.ZodString, string, string>;
+    channelId: z.ZodString;
+    userId: z.ZodString;
+    messageParentId: z.ZodOptional<z.ZodString>;
+    assistantId: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    createdAt: z.ZodDate;
+    editedAt: z.ZodOptional<z.ZodDate>;
+    fileIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    vars: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    createdAt: Date;
+    userId: string;
+    channelId: string;
+    messageId: string;
+    assistantId?: string | undefined;
+    vars?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+    messageParentId?: string | undefined;
+    editedAt?: Date | undefined;
+    fileIds?: string[] | undefined;
+}, {
+    message: string;
+    createdAt: Date;
+    userId: string;
+    channelId: string;
+    messageId: string;
+    assistantId?: string | undefined;
+    vars?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+    messageParentId?: string | undefined;
+    editedAt?: Date | undefined;
+    fileIds?: string[] | undefined;
+}>;
+export type IMessage = z.infer<typeof messageSchema>;
+export declare function Messages(dataContext?: DataContext): import("./orm").Table<{
+    message: string;
+    createdAt: Date;
+    userId: string;
+    channelId: string;
+    messageId: string;
+    assistantId?: string | undefined;
+    vars?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+    messageParentId?: string | undefined;
+    editedAt?: Date | undefined;
+    fileIds?: string[] | undefined;
+}>;
+interface ISendMessageArgs {
+    channelOrThreadIdOrWorkflowRunId: string;
+    assistantId?: string;
+    messageContent: string;
+}
+export declare function sendMessage(args: ISendMessageArgs): Promise<IMessage>;
+export declare function getThreadVars(message: IMessage): Promise<Record<string, any>>;
+export {};

package/dist/data/messages.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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 table_definitions_system_1 = require("./orm/table-definitions.system");
+exports.messageSchema = zod_1.z.object({
+    messageId: zod_types_1.zodPeerId,
+    channelId: zod_1.z.string().describe('The id of the channel this message entry belongs to'),
+    userId: zod_1.z.string().describe('The id of the user who created this message entry'),
+    messageParentId: zod_1.z.string().optional().describe('The id of the parent message entry if this is part of a thread'),
+    assistantId: zod_1.z.string().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_1.z.string().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',
+    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'] },
+    ]
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.messageSchema);
+function Messages(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.messageSchema);
+}
+async function sendMessage(args) {
+    const { channelOrThreadIdOrWorkflowRunId, assistantId, messageContent } = args;
+    let channelId = channelOrThreadIdOrWorkflowRunId;
+    let parentMessage = await Messages().get(channelOrThreadIdOrWorkflowRunId);
+    if (!parentMessage) {
+        const workflowRun = await (0, workflow_runs_1.WorkflowRuns)().get(channelOrThreadIdOrWorkflowRunId);
+        if (workflowRun) {
+            parentMessage = await Messages().get(workflowRun.parentMessageId);
+        }
+    }
+    if (parentMessage) {
+        channelId = parentMessage.channelId;
+    }
+    else {
+        const channel = await (0, channels_1.Channels)().get(channelOrThreadIdOrWorkflowRunId);
+        if (!channel) {
+            // check if channel is a user id
+            const user = await (0, users_1.Users)().get(channelOrThreadIdOrWorkflowRunId);
+            if (!user) {
+                throw new Error(`Channel ${channelOrThreadIdOrWorkflowRunId} not found.  A channel must be a valid channelId or userId or groupId.`);
+            }
+        }
+    }
+    const me = await (0, users_1.getMe)();
+    const message = await Messages().insert({
+        messageId: (0, utils_1.newid)(),
+        channelId,
+        userId: me.userId,
+        messageParentId: parentMessage?.messageParentId ?? parentMessage?.messageId,
+        assistantId,
+        message: messageContent,
+        createdAt: new Date(),
+    });
+    return message;
+}
+async function getThreadVars(message) {
+    const $or = [
+        { messageId: message.messageId },
+    ];
+    if (message.messageParentId) {
+        $or.push({ messageId: message.messageParentId });
+    }
+    const threadMessages = await Messages().list({
+        $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 ?? {});
+        return acc;
+    }, {});
+    return vars;
+}

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { DataFilter, ICursorIterable, IDataQueryParams, IDataSource, ISaveOptions } from "./data-query";
+import { ITableMetaData } from "./types";
+export declare class ClientProxyDataSource<T extends {
+    [key: string]: any;
+}> implements IDataSource<T> {
+    readonly metaData: ITableMetaData;
+    readonly schema: z.AnyZodObject;
+    readonly dataContextId: string;
+    readonly tableName: string;
+    readonly primaryKeyName: string;
+    constructor(metaData: ITableMetaData, schema: z.AnyZodObject, dataContextId: string);
+    get(id: string, opts?: {
+        useCache?: boolean;
+        cacheTtlMs?: number;
+    }): Promise<T | undefined>;
+    list(filter?: DataFilter<T>, opts?: IDataQueryParams<T>): Promise<T[]>;
+    count(filter?: DataFilter<T>): Promise<number>;
+    cursor(filter?: DataFilter<T>, opts?: IDataQueryParams<T>): ICursorIterable<T>;
+    findOne(filter: DataFilter<T> | undefined, opts: {
+        enforceUnique?: boolean;
+    }): Promise<T | undefined>;
+    save(record: T, opts?: ISaveOptions): Promise<T>;
+    insert(record: T): Promise<T>;
+    update(record: T): Promise<T>;
+    delete(idOrRecord: string | T): Promise<void>;
+}

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientProxyDataSource = void 0;
+const rpc_types_1 = require("../../rpc-types");
+const data_query_1 = require("./data-query");
+const types_1 = require("./types");
+const utils_1 = require("../../utils");
+class ClientProxyDataSource {
+    metaData;
+    schema;
+    dataContextId;
+    tableName;
+    primaryKeyName;
+    constructor(metaData, schema = (0, types_1.fieldsToSchema)(metaData.fields), dataContextId) {
+        this.metaData = metaData;
+        this.schema = schema;
+        this.dataContextId = dataContextId;
+        this.tableName = (0, utils_1.getFullTableName)(metaData);
+        this.primaryKeyName = 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.tableGet(this.dataContextId, this.tableName, id, opts);
+    }
+    async list(filter = {}, opts = {}) {
+        return rpc_types_1.rpcServerCalls.tableList(this.dataContextId, this.tableName, filter, opts);
+    }
+    ;
+    async count(filter = {}) {
+        return rpc_types_1.rpcServerCalls.tableCount(this.dataContextId, this.tableName, filter);
+    }
+    ;
+    cursor(filter = {}, opts = {}) {
+        return (0, data_query_1.dataSourceCursor)(this, filter, opts);
+    }
+    async findOne(filter = {}, opts) {
+        if (!opts?.enforceUnique) {
+            const records = await this.list(filter, { pageSize: 1 });
+            return records[0];
+        }
+        else {
+            const records = await this.list(filter, { pageSize: 2 });
+            if (records.length > 1) {
+                throw new Error(`Matched more than one record for ${this.tableName} with query ${JSON.stringify(filter)}`);
+            }
+            return records[0];
+        }
+    }
+    async save(record, opts) {
+        return rpc_types_1.rpcServerCalls.tableSave(this.dataContextId, this.tableName, record, opts);
+    }
+    async insert(record) {
+        return rpc_types_1.rpcServerCalls.tableInsert(this.dataContextId, this.tableName, record);
+    }
+    async update(record) {
+        return rpc_types_1.rpcServerCalls.tableUpdate(this.dataContextId, this.tableName, record);
+    }
+    async delete(idOrRecord) {
+        return rpc_types_1.rpcServerCalls.tableDelete(this.dataContextId, this.tableName, idOrRecord);
+    }
+}
+exports.ClientProxyDataSource = ClientProxyDataSource;

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

@@ -0,0 +1,25 @@
+import { ICursorIterable, DataFilter, IDataQueryParams } from './data-query';
+export declare class Cursor<T> implements ICursorIterable<T> {
+    private _cursor;
+    constructor(_cursor: ICursorIterable<T>);
+    get value(): T | null;
+    next(skipPast?: T): Promise<T | null>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    static from<T>(cursor: ICursorIterable<T>): Cursor<T>;
+    static fromDataSource<T extends {
+        [key: string]: any;
+    }>(dataSource: {
+        list: (filter?: DataFilter<T>, opts?: IDataQueryParams<T>) => Promise<T[]>;
+        primaryKeyName: string;
+    }, filter?: DataFilter<T>, opts?: IDataQueryParams<T>): Cursor<T>;
+    static fromDataSources<T extends {
+        [key: string]: any;
+    }>(dataSources: {
+        list: (filter?: DataFilter<T>, opts?: IDataQueryParams<T>) => Promise<T[]>;
+        primaryKeyName: string;
+    }[], filter?: DataFilter<T>, opts?: IDataQueryParams<T>): Cursor<T>;
+    static union<T>(...cursors: (ICursorIterable<T> | Cursor<T>)[]): Cursor<T>;
+    union(...others: (ICursorIterable<T> | Cursor<T>)[]): Cursor<T>;
+    map<U>(mapFn: (item: T) => U | Promise<U>): Cursor<U>;
+    filter(filterFn: (item: T) => boolean | Promise<boolean>): Cursor<T>;
+}

package/dist/data/orm/cursor.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cursor = void 0;
+const data_query_1 = require("./data-query");
+const multi_cursors_1 = require("./multi-cursors");
+class Cursor {
+    _cursor;
+    constructor(_cursor) {
+        this._cursor = _cursor;
+    }
+    get value() {
+        return this._cursor.value;
+    }
+    async next(skipPast) {
+        return this._cursor.next(skipPast);
+    }
+    [Symbol.asyncIterator]() {
+        return this._cursor[Symbol.asyncIterator]();
+    }
+    // Static factory methods
+    static from(cursor) {
+        return new Cursor(cursor);
+    }
+    static fromDataSource(dataSource, filter = {}, opts = {}) {
+        return new Cursor((0, data_query_1.dataSourceCursor)(dataSource, filter, opts));
+    }
+    static fromDataSources(dataSources, filter = {}, opts = {}) {
+        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);
+        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);
+        return new Cursor((0, multi_cursors_1.cursorUnion)(unwrappedCursors));
+    }
+    map(mapFn) {
+        return new Cursor((0, multi_cursors_1.cursorMap)(this._cursor, mapFn));
+    }
+    filter(filterFn) {
+        return new Cursor((0, multi_cursors_1.cursorFilter)(this._cursor, filterFn));
+    }
+}
+exports.Cursor = Cursor;

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

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