@peers-app/peers-sdk 0.7.2 → 0.7.5

package/dist/context/data-context.d.ts

@@ -10,8 +10,8 @@ export declare class DataContext {
     readonly tableContainer: TableContainer;
     readonly packageLoader: PackageLoader;
     readonly eventRegistry: EventRegistry;
+    readonly dataContextId: string;
     constructor(userContext: UserContext, groupId?: string | undefined);
-    get dataContextId(): string;
     /**
      * Call this to indicate that this should be the current data context to be used unless otherwise specified
      */

package/dist/context/data-context.js

@@ -10,9 +10,11 @@ class DataContext {
     tableContainer;
     packageLoader;
     eventRegistry;
+    dataContextId;
     constructor(userContext, groupId) {
         this.userContext = userContext;
         this.groupId = groupId;
+        this.dataContextId = groupId || userContext.userId;
         // Initialize dependencies in the correct order to avoid circular references
         this.eventRegistry = new orm_1.EventRegistry(this.dataContextId);
         this.packageLoader = new package_loader_1.PackageLoader(this);
@@ -23,9 +25,6 @@ class DataContext {
         const tableFactory = (metaData, schema, TableClass) => this.createTable(metaData, schema, TableClass);
         this.tableContainer = new orm_1.TableContainer(tableFactory, groupId);
     }
-    get dataContextId() {
-        return this.groupId || this.userContext.userId;
-    }
     /**
      * Call this to indicate that this should be the current data context to be used unless otherwise specified
      */

package/dist/context/user-context-singleton.js

@@ -55,7 +55,7 @@ function getTableContainer(dataContext) {
 }
 function setDefaultClientUserContext(userId) {
     const clientProxyDataSourceFactory = (metaData, schema, groupId) => {
-        return new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, groupId ?? '');
+        return new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, groupId || userId);
     };
     const userContext = new user_context_1.UserContext(userId, clientProxyDataSourceFactory);
     (async () => {
@@ -86,38 +86,20 @@ if (!rpc_types_1.isClient) {
             .getTable(tableName);
         return table;
     }
-    // TODO: add check that client has permission to do the operation to the table
-    rpc_types_1.rpcServerCalls.tableGet = async (dataContextId, tableName, id) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.get(id);
-    };
-    rpc_types_1.rpcServerCalls.tableList = async (dataContextId, tableName, filter, opts) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.list(filter, opts);
-    };
-    rpc_types_1.rpcServerCalls.tableCount = async (dataContextId, tableName, filter) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.count(filter);
-    };
-    rpc_types_1.rpcServerCalls.tableSave = async (dataContextId, tableName, data, opts) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.save(data, opts);
-    };
-    rpc_types_1.rpcServerCalls.tableInsert = async (dataContextId, tableName, data) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.insert(data);
-    };
-    rpc_types_1.rpcServerCalls.tableUpdate = async (dataContextId, tableName, data) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.update(data);
-    };
-    rpc_types_1.rpcServerCalls.tableDelete = async (dataContextId, tableName, idOrRecord) => {
-        const table = await getTable(dataContextId, tableName);
-        return table.delete(idOrRecord);
-    };
+    // TODO: add check that client has permission to make this call
     rpc_types_1.rpcServerCalls.tableMethodCall = async (dataContextId, tableName, methodName, ...args) => {
+        if (!tableName) {
+            throw new Error('tableName is required for tableMethodCall');
+        }
+        if (!dataContextId) {
+            console.warn('dataContextId not provided to tableMethodCall - defaulting to user context.  This is discouraged. If userDataContext was intended then pass it in explicitly.');
+        }
         const table = await getTable(dataContextId, tableName);
-        // @ts-ignore
+        const method = table[methodName];
+        if (typeof method !== 'function') {
+            throw new Error(`Method ${methodName} not found on table ${tableName}`);
+        }
+        // @ts-ignore - call this way to ensure 'this' is correct
         return table[methodName](...args);
     };
 }

package/dist/context/user-context.d.ts

@@ -1,7 +1,6 @@
 import { DataContext } from "../context/data-context";
 import { IUser } from "../data";
 import type { DataSourceFactory, IDataChangedEvent, Table } from "../data/orm";
-import { TrustLevel } from "../device/socket.type";
 import { IPublicPrivateKeys } from "../keys";
 import { Observable } from "../observable";
 export declare class UserContext {
@@ -9,7 +8,6 @@ export declare class UserContext {
     readonly dataSourceFactory: DataSourceFactory;
     readonly deviceId: Observable<string>;
     readonly currentlyActiveGroupId: Observable<string | undefined>;
-    readonly packagesRootDir: Observable<string>;
     readonly reloadPackagesOnPageRefresh: Observable<boolean>;
     readonly groupIds: Observable<string[]>;
     readonly userDataContext: DataContext;
@@ -34,15 +32,14 @@ export declare class UserContext {
     getMe(): Promise<{
         name: string;
         publicKey: string;
-        publicBoxKey: string;
         userId: string;
+        publicBoxKey: string;
         signature?: string | undefined;
-        trustLevel?: TrustLevel | undefined;
     } | undefined>;
     syncUserAndGroupObjects(userId: string, keys: IPublicPrivateKeys, me?: IUser): Promise<void>;
     subscribeToDataChangedAcrossAllGroups<T extends {
         [key: string]: any;
-    }>(table: Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;
+    }>(table: string | Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;
 }
 export interface ICrossGroupSubscriptionHandlerArgs<T> {
     name: string;

package/dist/context/user-context.js

@@ -4,7 +4,6 @@ exports.UserContext = void 0;
 const lodash_1 = require("lodash");
 const data_context_1 = require("../context/data-context");
 const data_1 = require("../data");
-const socket_type_1 = require("../device/socket.type");
 const events_1 = require("../events");
 const keys_1 = require("../keys");
 const observable_1 = require("../observable");
@@ -14,7 +13,6 @@ class UserContext {
     dataSourceFactory;
     deviceId = (0, observable_1.observable)('');
     currentlyActiveGroupId = (0, observable_1.observable)();
-    packagesRootDir = (0, observable_1.observable)('');
     reloadPackagesOnPageRefresh = (0, observable_1.observable)(false);
     groupIds = (0, observable_1.observable)([]);
     userDataContext;
@@ -30,7 +28,12 @@ class UserContext {
         this.loadingPromise = this.init();
     }
     async init() {
-        await this.loadUserContextObservablesFromDB();
+        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            console.log(`not setting up user-context pvars during tests because they will interfere with other UserContext instances`);
+        }
+        else {
+            await this.loadUserContextObservablesFromDB();
+        }
         await this.loadGroupContexts();
         await this.loadAllPackages();
         return this;
@@ -107,8 +110,9 @@ class UserContext {
      * for the user context to be fully loaded before proceeding with standard data access
      */
     async loadUserContextObservablesFromDB() {
-        const persistentVars = await this.userDataContext.tableContainer.getTableByName(data_1.persistentVarsMetaData.name);
-        const vars = await persistentVars.list({ name: { $in: ['myUserId', 'thisDeviceId', 'currentlyActiveGroupId', 'packagesRootDir', 'reloadPackagesOnPageRefresh'] } });
+        // const persistentVars: PersistentVarsTable = await this.userDataContext.tableContainer.getTableByName(persistentVarsMetaData.name) as PersistentVarsTable;
+        const persistentVars = (0, data_1.PersistentVars)(this.userDataContext);
+        const vars = await persistentVars.list({ name: { $in: ['thisDeviceId', 'currentlyActiveGroupId', 'reloadPackagesOnPageRefresh'] } });
         const varDbValues = vars.reduce((acc, curr) => {
             acc[curr.name] = curr.value?.value;
             return acc;
@@ -120,15 +124,11 @@ class UserContext {
         const currentlyActiveGroupIdPVar = (0, data_1.deviceVar)('currentlyActiveGroupId', { dbValue: varDbValues['currentlyActiveGroupId'], defaultValue: '', userContext: this });
         this.currentlyActiveGroupId(currentlyActiveGroupIdPVar());
         (0, observable_1.linkObservables)(currentlyActiveGroupIdPVar, this.currentlyActiveGroupId);
-        const packagesRootDirPVar = (0, data_1.deviceVar)('packagesRootDir', { defaultValue: '~/peers-packages', dbValue: varDbValues['packagesRootDir'], userContext: this });
-        this.packagesRootDir(packagesRootDirPVar());
-        (0, observable_1.linkObservables)(packagesRootDirPVar, this.packagesRootDir);
         const reloadPackagesOnPageRefreshPVar = (0, data_1.deviceVar)('reloadPackagesOnPageRefresh', { defaultValue: false, dbValue: varDbValues['reloadPackagesOnPageRefresh'], userContext: this });
         this.reloadPackagesOnPageRefresh(reloadPackagesOnPageRefreshPVar());
         (0, observable_1.linkObservables)(reloadPackagesOnPageRefreshPVar, this.reloadPackagesOnPageRefresh);
         await Promise.all([
             deviceIdPVar.loadingPromise,
-            packagesRootDirPVar.loadingPromise,
             reloadPackagesOnPageRefreshPVar.loadingPromise,
         ]);
     }
@@ -148,7 +148,6 @@ class UserContext {
                 name: 'Unnamed_1',
                 publicKey: '',
                 publicBoxKey: '',
-                trustLevel: socket_type_1.TrustLevel.Self,
             };
         }
         me.publicKey = keys.publicKey;
@@ -162,9 +161,8 @@ class UserContext {
         // sync my user to all all my groups
         for (const [, dataContext] of userContext.groupDataContexts) {
             let groupMe = await (0, data_1.Users)(dataContext).get(me.userId);
-            if (!groupMe || groupMe.name !== me.name || groupMe.publicKey !== me.publicKey) {
-                groupMe = (0, keys_1.addSignatureToObject)({ ...me, trustLevel: groupMe?.trustLevel || socket_type_1.TrustLevel.NewUser }, keys.secretKey);
-                await (0, data_1.Users)(dataContext).save(groupMe);
+            if (!(0, lodash_1.isEqual)(groupMe, meSigned)) {
+                await (0, data_1.Users)(dataContext).save(meSigned);
             }
         }
         // sync group objects to my personal db
@@ -176,13 +174,20 @@ class UserContext {
             const groupObject = await (0, data_1.Groups)(dataContext).get(dataContext.groupId);
             const myGroupObject = await (0, data_1.Groups)(this.userDataContext).get(dataContext.groupId);
             if (groupObject && !(0, lodash_1.isEqual)(groupObject, myGroupObject)) {
-                (0, keys_1.verifyObjectSignature)(groupObject);
+                try {
+                    (0, keys_1.verifyObjectSignature)(groupObject);
+                }
+                catch (err) {
+                    console.error(`Error verifying group object from group ${dataContext.groupId}:`, err);
+                    continue;
+                }
                 await (0, data_1.Groups)(this.userDataContext).save(groupObject);
             }
         }
     }
     subscribeToDataChangedAcrossAllGroups(table, handler) {
-        const tableEventPrefix = `${table.tableName}_DataChanged_`;
+        const tableName = typeof table === 'string' ? table : table.tableName;
+        const tableEventPrefix = `${tableName}_DataChanged_`;
         const subscription = (0, events_1.subscribe)(evt => evt.name.startsWith(tableEventPrefix), async (evt) => {
             const dataContextId = evt.name.endsWith('_') ? this.userId : evt.name.split('_').pop();
             const dataContext = this.getDataContext(dataContextId);

package/dist/data/assistants.d.ts

@@ -39,7 +39,7 @@ export declare const assistantSchema: z.ZodObject<{
     toolInclusionStrategy?: ToolInclusionStrategy | undefined;
 }>;
 export type IAssistant = z.infer<typeof assistantSchema>;
-export declare function Assistants(dataContext?: DataContext): import("..").Table<{
+export declare function Assistants(dataContext?: DataContext): import("./orm").Table<{
     name: string;
     createdAt: Date;
     assistantId: string;

package/dist/data/change-tracking.d.ts

@@ -10,22 +10,22 @@ declare const insertChange: z.ZodObject<{
     recordId: z.ZodString;
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
 }, {
-    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -40,20 +40,20 @@ declare const deleteChange: z.ZodObject<{
     recordId: z.ZodString;
     oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }, {
-    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
 }>;
 export type IChangeDelete = z.infer<typeof deleteChange>;
@@ -67,23 +67,23 @@ declare const updateChange: z.ZodObject<{
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
     jsonDiff: z.ZodArray<z.ZodAny, "many">;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
     jsonDiff: any[];
 }, {
-    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -99,22 +99,22 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     recordId: z.ZodString;
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
 }, {
-    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -127,20 +127,20 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     recordId: z.ZodString;
     oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }, {
-    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
 }>, z.ZodObject<{
     changeId: z.ZodEffects<z.ZodString, string, string>;
@@ -152,23 +152,23 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
     jsonDiff: z.ZodArray<z.ZodAny, "many">;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
     jsonDiff: any[];
 }, {
-    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -186,25 +186,25 @@ export declare const changeTrackingSchema: z.ZodObject<{
     newRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
     jsonDiff: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     changeId: string;
     changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
-    jsonDiff?: any[] | undefined;
     oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+    jsonDiff?: any[] | undefined;
 }, {
-    recordId: string;
     changeId: string;
     changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
+    recordId: string;
     newRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
-    jsonDiff?: any[] | undefined;
     oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+    jsonDiff?: any[] | undefined;
 }>;
 export type IChangeAny = z.infer<typeof changeTrackingSchema>;
 export declare class ChangeTrackingTable extends SQLDataSource<IChange> {

package/dist/data/channels.d.ts

@@ -20,7 +20,7 @@ export declare const channelSchema: z.ZodObject<{
     owningGroupId: string;
 }>;
 export type IChannel = z.infer<typeof channelSchema>;
-export declare function Channels(dataContext?: DataContext): import("..").Table<{
+export declare function Channels(dataContext?: DataContext): import("./orm").Table<{
     name: string;
     description: string;
     createdAt: Date;

package/dist/data/data-locks.d.ts

@@ -7,13 +7,13 @@ export declare const dataLockSchema: z.ZodObject<{
     lockedUntil: z.ZodNumber;
     acknowledged: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    dataLockId: string;
     recordId: string;
+    dataLockId: string;
     lockedUntil: number;
     acknowledged?: number | undefined;
 }, {
-    dataLockId: string;
     recordId: string;
+    dataLockId: string;
     lockedUntil: number;
     acknowledged?: number | undefined;
 }>;

package/dist/data/data-locks.test.js

@@ -90,6 +90,9 @@ class MockPeerDevice {
             timestampLastApplied: Date.now()
         }));
     }
+    sendDeviceMessage(message) {
+        throw new Error('Method not implemented.');
+    }
 }
 describe('data-locks.ts', () => {
     const fiveMinutesMs = 5 * 60 * 1000;

package/dist/data/devices.d.ts

@@ -11,18 +11,18 @@ export declare const deviceSchema: z.ZodObject<{
     trustLevel: z.ZodNativeEnum<typeof TrustLevel>;
 }, "strip", z.ZodTypeAny, {
     userId: string;
-    trustLevel: TrustLevel;
     deviceId: string;
     firstSeen: Date;
     lastSeen: Date;
+    trustLevel: TrustLevel;
     name?: string | undefined;
     serverUrl?: string | undefined;
 }, {
     userId: string;
-    trustLevel: TrustLevel;
     deviceId: string;
     firstSeen: Date;
     lastSeen: Date;
+    trustLevel: TrustLevel;
     name?: string | undefined;
     serverUrl?: string | undefined;
 }>;
@@ -38,12 +38,12 @@ export interface IDeviceHandshake extends IDeviceInfo {
     serverAddress: string;
     timestamp: number;
 }
-export declare function Devices(dataContext?: DataContext): import("..").Table<{
+export declare function Devices(dataContext?: DataContext): import("./orm").Table<{
     userId: string;
-    trustLevel: TrustLevel;
     deviceId: string;
     firstSeen: Date;
     lastSeen: Date;
+    trustLevel: TrustLevel;
     name?: string | undefined;
     serverUrl?: string | undefined;
 }>;

package/dist/data/embeddings.d.ts

@@ -34,7 +34,7 @@ export declare const embeddingSchema: z.ZodObject<{
     embeddingType: string;
 }>;
 export type IEmbedding = z.infer<typeof embeddingSchema>;
-export declare function Embeddings(dataContext?: DataContext): import("..").Table<{
+export declare function Embeddings(dataContext?: DataContext): import("./orm").Table<{
     metadata: {
         fkId?: string | undefined;
     } & {

package/dist/data/group-members.d.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
-import { Table } from "./orm";
 import { GroupMemberRole } from './group-member-roles';
-import { ISaveOptions } from "..";
+import type { ISaveOptions } from "./orm/data-query";
+import { Table } from "./orm/table";
 export declare const groupMemberSchema: z.ZodObject<{
     groupMemberId: z.ZodEffects<z.ZodString, string, string>;
     groupId: z.ZodEffects<z.ZodString, string, string>;
@@ -13,16 +13,16 @@ export declare const groupMemberSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     role: GroupMemberRole;
     signature: string;
-    groupId: string;
     userId: string;
     groupMemberId: string;
+    groupId: string;
     deleted?: boolean | undefined;
 }, {
     role: GroupMemberRole;
     signature: string;
-    groupId: string;
     userId: string;
     groupMemberId: string;
+    groupId: string;
     deleted?: boolean | undefined;
 }>;
 export type IGroupMember = z.infer<typeof groupMemberSchema>;
@@ -30,7 +30,10 @@ export declare const groupMembersTableName = "GroupMembers";
 export declare class GroupMembersTable extends Table<IGroupMember> {
     static isPassthrough: boolean;
     save(groupMember: IGroupMember, opts?: ISaveOptions): Promise<IGroupMember>;
+    signAndSave(groupMember: IGroupMember, opts?: ISaveOptions): Promise<IGroupMember>;
     delete(groupMemberId: string): Promise<void>;
+    private static addSignatureToGroupMember;
+    static enableGroupMemberSigning(fn: (groupMember: IGroupMember) => IGroupMember): void;
     /** @deprecated Forbidden on GroupsTable; use save() */
     insert(..._args: Parameters<Table<IGroupMember>['insert']>): never;
     /** @deprecated Forbidden on GroupsTable; use save() */