@peers-app/peers-sdk 0.7.2 → 0.7.3

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

@@ -86,38 +86,14 @@ 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) => {
         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 {
@@ -34,10 +33,9 @@ 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 {

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");
@@ -148,7 +147,6 @@ class UserContext {
                 name: 'Unnamed_1',
                 publicKey: '',
                 publicBoxKey: '',
-                trustLevel: socket_type_1.TrustLevel.Self,
             };
         }
         me.publicKey = keys.publicKey;
@@ -162,9 +160,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,7 +173,13 @@ 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);
             }
         }

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/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() */

package/dist/data/group-members.js

@@ -1,16 +1,51 @@
 "use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupMembersTable = exports.groupMembersTableName = exports.groupMemberSchema = void 0;
 exports.GroupMembers = GroupMembers;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
+const decorators_1 = require("../data/orm/decorators");
 const zod_types_1 = require("../types/zod-types");
-const orm_1 = require("./orm");
-const table_definitions_system_1 = require("./orm/table-definitions.system");
-const types_1 = require("./orm/types");
 const group_member_roles_1 = require("./group-member-roles");
 const group_permissions_1 = require("./group-permissions");
-const __1 = require("..");
+const table_1 = require("./orm/table");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
+const users_1 = require("./users");
 exports.groupMemberSchema = zod_1.z.object({
     groupMemberId: zod_types_1.zodPeerId,
     groupId: zod_types_1.zodPeerId.describe('The id of the group'),
@@ -29,38 +64,69 @@ const metaData = {
         { fields: ['groupId', 'userId'], unique: true },
     ]
 };
-class GroupMembersTable extends orm_1.Table {
-    static isPassthrough = false;
-    async save(groupMember, opts) {
-        if (GroupMembersTable.isPassthrough) {
-            return super.save(groupMember, opts);
+let GroupMembersTable = (() => {
+    let _classSuper = table_1.Table;
+    let _instanceExtraInitializers = [];
+    let _signAndSave_decorators;
+    return class GroupMembersTable extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _signAndSave_decorators = [(0, decorators_1.ProxyClientTableMethodCalls)()];
+            __esDecorate(this, null, _signAndSave_decorators, { kind: "method", name: "signAndSave", static: false, private: false, access: { has: obj => "signAndSave" in obj, get: obj => obj.signAndSave }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        const oldGroupMember = groupMember.groupMemberId ? await this.get(groupMember.groupMemberId) : undefined;
-        if (await (0, group_permissions_1.isGroupMemberSignatureValid)(groupMember.groupId, groupMember, oldGroupMember)) {
-            return super.save(groupMember, opts);
+        static isPassthrough = false;
+        async save(groupMember, opts) {
+            if (GroupMembersTable.isPassthrough) {
+                return super.save(groupMember, opts);
+            }
+            const me = await (0, users_1.getMe)();
+            if (groupMember.groupId === me.userId) {
+                throw new Error('Group members cannot be added to personal user contexts');
+            }
+            const oldGroupMember = groupMember.groupMemberId ? await this.get(groupMember.groupMemberId) : undefined;
+            if (await (0, group_permissions_1.isGroupMemberSignatureValid)(groupMember.groupId, groupMember, oldGroupMember)) {
+                return super.save(groupMember, opts);
+            }
+            throw new Error('Group member signature is not valid');
         }
-        throw new Error('Group member signature is not valid');
-    }
-    async delete(groupMemberId) {
-        if (GroupMembersTable.isPassthrough) {
-            return super.delete(groupMemberId);
+        async signAndSave(groupMember, opts) {
+            if (!GroupMembersTable.addSignatureToGroupMember) {
+                throw new Error('Group member signing must be enabled to sign and save group members. Call GroupMembersTable.enableGroupMemberSigning(fn) to enable it.');
+            }
+            groupMember = GroupMembersTable.addSignatureToGroupMember(groupMember);
+            return this.save(groupMember, opts);
         }
-        const groupMember = await this.get(groupMemberId);
-        if (groupMember) {
-            groupMember.deleted = true;
-            groupMember.role = group_member_roles_1.GroupMemberRole.None;
-            await __1.rpcServerCalls.tableSave(groupMember.groupId, "GroupMembers", groupMember);
+        async delete(groupMemberId) {
+            if (GroupMembersTable.isPassthrough) {
+                return super.delete(groupMemberId);
+            }
+            const groupMember = await this.get(groupMemberId);
+            if (groupMember) {
+                groupMember.deleted = true;
+                groupMember.role = group_member_roles_1.GroupMemberRole.None;
+                // we do a soft delete by saving the object with deleted=true and
+                await this.signAndSave(groupMember);
+            }
         }
-    }
-    /** @deprecated Forbidden on GroupsTable; use save() */
-    insert(..._args) {
-        throw new Error('GroupsTable forbids insert; use save()');
-    }
-    /** @deprecated Forbidden on GroupsTable; use save() */
-    update(..._args) {
-        throw new Error('GroupsTable forbids update; use save()');
-    }
-}
+        static addSignatureToGroupMember = undefined;
+        static enableGroupMemberSigning(fn) {
+            GroupMembersTable.addSignatureToGroupMember = fn;
+        }
+        /** @deprecated Forbidden on GroupsTable; use save() */
+        insert(..._args) {
+            throw new Error('GroupsTable forbids insert; use save()');
+        }
+        /** @deprecated Forbidden on GroupsTable; use save() */
+        update(..._args) {
+            throw new Error('GroupsTable forbids update; use save()');
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+})();
 exports.GroupMembersTable = GroupMembersTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.groupMemberSchema, GroupMembersTable);
 function GroupMembers(dataContext) {

package/dist/data/groups.d.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
 import { GroupMemberRole } from "./group-member-roles";
-import { ISaveOptions, Table } from "./orm";
+import type { ISaveOptions } from "./orm/data-query";
+import { Table } from "./orm/table";
 export declare const groupSchema: z.ZodObject<{
     groupId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
@@ -18,9 +19,9 @@ export declare const groupSchema: z.ZodObject<{
     description: string;
     signature: string;
     publicKey: string;
+    publicBoxKey: string;
     groupId: string;
     founderUserId: string;
-    publicBoxKey: string;
     disabled?: boolean | undefined;
     iconClassName?: string | undefined;
     publicRole?: GroupMemberRole | undefined;
@@ -29,9 +30,9 @@ export declare const groupSchema: z.ZodObject<{
     description: string;
     signature: string;
     publicKey: string;
+    publicBoxKey: string;
     groupId: string;
     founderUserId: string;
-    publicBoxKey: string;
     disabled?: boolean | undefined;
     iconClassName?: string | undefined;
     publicRole?: GroupMemberRole | undefined;
@@ -41,7 +42,10 @@ export declare const groupsTableName = "Groups";
 export declare class GroupsTable extends Table<IGroup> {
     static isPassthrough: boolean;
     save(group: IGroup, opts?: ISaveOptions): Promise<IGroup>;
+    signAndSave(group: IGroup, opts?: ISaveOptions): Promise<IGroup>;
     delete(groupId: string): Promise<void>;
+    private static addSignatureToGroup;
+    static enableGroupSigning(fn: (group: IGroup) => IGroup): void;
     /** @deprecated Direct inserts forbidden; use save() */
     insert(..._args: Parameters<Table<IGroup>['insert']>): never;
     /** @deprecated Direct updates forbidden; use save() */