@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/files/index.d.ts

@@ -1,4 +1,4 @@
-export * from './file.types';
-export * from './files';
-export { FileWriteStream } from './file-write-stream';
-export { FileReadStream } from './file-read-stream';
+export * from "./file.types";
+export { FileReadStream } from "./file-read-stream";
+export { FileWriteStream } from "./file-write-stream";
+export * from "./files";

package/dist/data/files/index.js

@@ -14,10 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileReadStream = exports.FileWriteStream = void 0;
+exports.FileWriteStream = exports.FileReadStream = void 0;
 __exportStar(require("./file.types"), exports);
-__exportStar(require("./files"), exports);
-var file_write_stream_1 = require("./file-write-stream");
-Object.defineProperty(exports, "FileWriteStream", { enumerable: true, get: function () { return file_write_stream_1.FileWriteStream; } });
 var file_read_stream_1 = require("./file-read-stream");
 Object.defineProperty(exports, "FileReadStream", { enumerable: true, get: function () { return file_read_stream_1.FileReadStream; } });
+var file_write_stream_1 = require("./file-write-stream");
+Object.defineProperty(exports, "FileWriteStream", { enumerable: true, get: function () { return file_write_stream_1.FileWriteStream; } });
+__exportStar(require("./files"), exports);

package/dist/data/group-member-roles.js

@@ -13,7 +13,7 @@ var GroupMemberRole;
 })(GroupMemberRole || (exports.GroupMemberRole = GroupMemberRole = {}));
 function getRoleLabel(value) {
     const roleEntries = Object.entries(GroupMemberRole)
-        .filter(([key, val]) => typeof val === 'number')
+        .filter(([_key, val]) => typeof val === "number")
         .map(([key, val]) => ({ level: val, label: key }))
         .sort((a, b) => b.level - a.level);
     for (const role of roleEntries) {
@@ -21,5 +21,5 @@ function getRoleLabel(value) {
             return value === role.level ? role.label : `${role.label}+`;
         }
     }
-    return 'None';
+    return "None";
 }

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
-import { GroupMemberRole } from './group-member-roles';
+import { GroupMemberRole } from "./group-member-roles";
 import type { ISaveOptions } from "./orm/data-query";
 import { Table } from "./orm/table";
 export declare const groupMemberSchema: z.ZodObject<{
@@ -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>;
@@ -35,8 +35,8 @@ export declare class GroupMembersTable extends Table<IGroupMember> {
     private static addSignatureToGroupMember;
     static enableGroupMemberSigning(fn: (groupMember: IGroupMember) => IGroupMember): void;
     /** @deprecated Forbidden on GroupsTable; use save() */
-    insert(..._args: Parameters<Table<IGroupMember>['insert']>): never;
+    insert(..._args: Parameters<Table<IGroupMember>["insert"]>): never;
     /** @deprecated Forbidden on GroupsTable; use save() */
-    update(..._args: Parameters<Table<IGroupMember>['update']>): never;
+    update(..._args: Parameters<Table<IGroupMember>["update"]>): never;
 }
 export declare function GroupMembers(dataContext?: DataContext): GroupMembersTable;

package/dist/data/group-members.js

@@ -48,21 +48,24 @@ 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'),
-    userId: zod_types_1.zodPeerId.describe('The id of the user who is a member of the group'),
-    role: zod_1.z.nativeEnum(group_member_roles_1.GroupMemberRole).describe('The role of the user in the group.  Use "none" to explicitly block a user'),
-    signature: zod_1.z.string().describe('The signed hash of this data excluding the signature itself'),
-    deleted: zod_1.z.boolean().optional().describe('Whether this membership has been deleted (soft delete)'),
+    groupId: zod_types_1.zodPeerId.describe("The id of the group"),
+    userId: zod_types_1.zodPeerId.describe("The id of the user who is a member of the group"),
+    role: zod_1.z
+        .nativeEnum(group_member_roles_1.GroupMemberRole)
+        .describe('The role of the user in the group.  Use "none" to explicitly block a user'),
+    signature: zod_1.z.string().describe("The signed hash of this data excluding the signature itself"),
+    deleted: zod_1.z
+        .boolean()
+        .optional()
+        .describe("Whether this membership has been deleted (soft delete)"),
 });
-exports.groupMembersTableName = 'GroupMembers';
+exports.groupMembersTableName = "GroupMembers";
 const metaData = {
     name: exports.groupMembersTableName,
-    description: 'group membership associations',
-    primaryKeyName: 'groupMemberId',
+    description: "group membership associations",
+    primaryKeyName: "groupMemberId",
     fields: (0, types_1.schemaToFields)(exports.groupMemberSchema),
-    indexes: [
-        { fields: ['groupId', 'userId'], unique: true },
-    ]
+    indexes: [{ fields: ["groupId", "userId"], unique: true }],
 };
 let GroupMembersTable = (() => {
     let _classSuper = table_1.Table;
@@ -82,20 +85,26 @@ let GroupMembersTable = (() => {
             }
             const me = await (0, users_1.getMe)();
             if (groupMember.groupId === me.userId) {
-                throw new Error('Group members cannot be added to personal user contexts');
+                throw new Error("Group members cannot be added to personal user contexts");
             }
-            const oldGroupMember = groupMember.groupMemberId ? await this.get(groupMember.groupMemberId) : undefined;
+            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 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.');
+                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, { saveAsSnapshot: true, restoreIfDeleted: true, ...(opts || {}) });
+            return this.save(groupMember, {
+                saveAsSnapshot: true,
+                restoreIfDeleted: true,
+                ...(opts || {}),
+            });
         }
         async delete(groupMemberId) {
             if (GroupMembersTable.isPassthrough) {
@@ -115,11 +124,11 @@ let GroupMembersTable = (() => {
         }
         /** @deprecated Forbidden on GroupsTable; use save() */
         insert(..._args) {
-            throw new Error('GroupsTable forbids insert; use save()');
+            throw new Error("GroupsTable forbids insert; use save()");
         }
         /** @deprecated Forbidden on GroupsTable; use save() */
         update(..._args) {
-            throw new Error('GroupsTable forbids update; use save()');
+            throw new Error("GroupsTable forbids update; use save()");
         }
         constructor() {
             super(...arguments);

package/dist/data/group-members.test.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const keys_1 = require("../keys");
 const group_permissions_1 = require("./group-permissions");
 // Test the group members signature logic directly without ORM dependencies
-describe('Group Members Signature Logic', () => {
+describe("Group Members Signature Logic", () => {
     let testGroupMember;
     let ownerKeys;
     let adminKeys;
@@ -11,57 +11,57 @@ describe('Group Members Signature Logic', () => {
         ownerKeys = (0, keys_1.newKeys)();
         adminKeys = (0, keys_1.newKeys)();
         testGroupMember = {
-            groupMemberId: 'test-member-1',
-            groupId: 'test-group-1',
-            userId: 'test-user-1',
+            groupMemberId: "test-member-1",
+            groupId: "test-group-1",
+            userId: "test-user-1",
             role: group_permissions_1.GroupMemberRole.Reader,
-            signature: ''
+            signature: "",
         };
     });
-    describe('basic signature functionality', () => {
-        it('should add signature to group member object', () => {
+    describe("basic signature functionality", () => {
+        it("should add signature to group member object", () => {
             const signedGroupMember = (0, keys_1.addSignatureToObject)(testGroupMember, ownerKeys.secretKey);
             expect(signedGroupMember.signature).toBeTruthy();
-            expect(signedGroupMember.signature).toContain(':');
+            expect(signedGroupMember.signature).toContain(":");
             expect(signedGroupMember.groupId).toBe(testGroupMember.groupId);
             expect(signedGroupMember.userId).toBe(testGroupMember.userId);
             expect(signedGroupMember.role).toBe(testGroupMember.role);
         });
-        it('should verify valid signature', () => {
+        it("should verify valid signature", () => {
             const signedGroupMember = (0, keys_1.addSignatureToObject)(testGroupMember, ownerKeys.secretKey);
             const isValid = (0, keys_1.isObjectSignatureValid)(signedGroupMember);
             expect(isValid).toBe(true);
         });
-        it('should reject invalid signature after modification', () => {
+        it("should reject invalid signature after modification", () => {
             const signedGroupMember = (0, keys_1.addSignatureToObject)(testGroupMember, ownerKeys.secretKey);
             // Modify the group member after signing
             signedGroupMember.role = group_permissions_1.GroupMemberRole.Admin;
             const isValid = (0, keys_1.isObjectSignatureValid)(signedGroupMember);
             expect(isValid).toBe(false);
         });
-        it('should extract correct public key from signature', () => {
+        it("should extract correct public key from signature", () => {
             const signedGroupMember = (0, keys_1.addSignatureToObject)(testGroupMember, ownerKeys.secretKey);
             const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroupMember);
             expect(extractedKey).toBe(ownerKeys.publicKey);
         });
     });
-    describe('permission validation with group context', () => {
+    describe("permission validation with group context", () => {
         // Note: These tests use basic signature verification since the new permission system
         // requires actual user/group data context which isn't available in unit tests
-        it('should allow owner to add any role', () => {
+        it("should allow owner to add any role", () => {
             const memberWithAdminRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithAdminRole, ownerKeys.secretKey);
             expect(signedMember.signature).toBeTruthy();
             expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Admin);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
-        it('should allow admin to add non-admin roles', () => {
+        it("should allow admin to add non-admin roles", () => {
             const signedMember = (0, keys_1.addSignatureToObject)(testGroupMember, adminKeys.secretKey);
             expect(signedMember.signature).toBeTruthy();
             expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Reader);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
-        it('should allow admin to assign admin roles', () => {
+        it("should allow admin to assign admin roles", () => {
             const memberWithAdminRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithAdminRole, adminKeys.secretKey);
             expect(signedMember.signature).toBeTruthy();
@@ -69,125 +69,125 @@ describe('Group Members Signature Logic', () => {
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
     });
-    describe('role assignment rules', () => {
+    describe("role assignment rules", () => {
         // Note: These tests focus on basic signature functionality since the new permission system
         // requires actual user/group data context for role-based validation
-        it('should allow signing owner role', () => {
+        it("should allow signing owner role", () => {
             const memberWithOwnerRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Owner };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithOwnerRole, ownerKeys.secretKey);
             expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Owner);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
-        it('should allow signing founder role', () => {
+        it("should allow signing founder role", () => {
             const memberWithFounderRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Founder };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithFounderRole, ownerKeys.secretKey);
             expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Founder);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
-        it('should allow signing writer role', () => {
+        it("should allow signing writer role", () => {
             const memberWithWriterRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Writer };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithWriterRole, adminKeys.secretKey);
             expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Writer);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
-        it('should allow setting role to None (blocking user)', () => {
+        it("should allow setting role to None (blocking user)", () => {
             const memberWithNoneRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.None };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithNoneRole, adminKeys.secretKey);
             expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.None);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
-        it('should handle role modifications with signatures', () => {
+        it("should handle role modifications with signatures", () => {
             const demotedToWriter = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Writer };
             const signedMember = (0, keys_1.addSignatureToObject)(demotedToWriter, adminKeys.secretKey);
             expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Writer);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
     });
-    describe('signature tampering detection', () => {
-        it('should detect tampered signature', () => {
+    describe("signature tampering detection", () => {
+        it("should detect tampered signature", () => {
             const signedMember = (0, keys_1.addSignatureToObject)(testGroupMember, ownerKeys.secretKey);
             // Tamper with signature by adding extra characters
-            signedMember.signature = signedMember.signature + 'tampered';
+            signedMember.signature = `${signedMember.signature}tampered`;
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(false);
         });
-        it('should detect empty signature', () => {
-            testGroupMember.signature = '';
+        it("should detect empty signature", () => {
+            testGroupMember.signature = "";
             expect((0, keys_1.isObjectSignatureValid)(testGroupMember)).toBe(false);
         });
-        it('should detect malformed signature', () => {
-            testGroupMember.signature = 'malformed-signature';
+        it("should detect malformed signature", () => {
+            testGroupMember.signature = "malformed-signature";
             expect((0, keys_1.isObjectSignatureValid)(testGroupMember)).toBe(false);
         });
-        it('should handle signature without colon separator', () => {
-            testGroupMember.signature = 'noseparator';
+        it("should handle signature without colon separator", () => {
+            testGroupMember.signature = "noseparator";
             expect((0, keys_1.isObjectSignatureValid)(testGroupMember)).toBe(false);
             expect((0, keys_1.getPublicKeyFromObjectSignature)(testGroupMember)).toBeUndefined();
         });
     });
-    describe('complex group member objects', () => {
-        it('should handle all role types', () => {
+    describe("complex group member objects", () => {
+        it("should handle all role types", () => {
             const roles = [
                 group_permissions_1.GroupMemberRole.None,
                 group_permissions_1.GroupMemberRole.Reader,
                 group_permissions_1.GroupMemberRole.Writer,
                 group_permissions_1.GroupMemberRole.Admin,
                 group_permissions_1.GroupMemberRole.Owner,
-                group_permissions_1.GroupMemberRole.Founder
+                group_permissions_1.GroupMemberRole.Founder,
             ];
-            roles.forEach(role => {
+            roles.forEach((role) => {
                 const member = { ...testGroupMember, role };
                 const signedMember = (0, keys_1.addSignatureToObject)(member, ownerKeys.secretKey);
                 expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
                 expect(signedMember.role).toBe(role);
             });
         });
-        it('should handle different user and group IDs', () => {
+        it("should handle different user and group IDs", () => {
             const memberWithDifferentIds = {
                 ...testGroupMember,
-                groupMemberId: 'member-123',
-                groupId: 'group-456',
-                userId: 'user-789'
+                groupMemberId: "member-123",
+                groupId: "group-456",
+                userId: "user-789",
             };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithDifferentIds, ownerKeys.secretKey);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
-            expect(signedMember.groupMemberId).toBe('member-123');
-            expect(signedMember.groupId).toBe('group-456');
-            expect(signedMember.userId).toBe('user-789');
+            expect(signedMember.groupMemberId).toBe("member-123");
+            expect(signedMember.groupId).toBe("group-456");
+            expect(signedMember.userId).toBe("user-789");
         });
     });
-    describe('edge cases', () => {
-        it('should handle long IDs', () => {
+    describe("edge cases", () => {
+        it("should handle long IDs", () => {
             const memberWithLongIds = {
                 ...testGroupMember,
-                groupMemberId: 'A'.repeat(1000),
-                groupId: 'B'.repeat(1000),
-                userId: 'C'.repeat(1000)
+                groupMemberId: "A".repeat(1000),
+                groupId: "B".repeat(1000),
+                userId: "C".repeat(1000),
             };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithLongIds, ownerKeys.secretKey);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
-        it('should handle special characters in IDs', () => {
+        it("should handle special characters in IDs", () => {
             const memberWithSpecialIds = {
                 ...testGroupMember,
-                groupMemberId: 'member-🚀-test',
+                groupMemberId: "member-🚀-test",
                 groupId: 'group-"with"-quotes',
-                userId: 'user\nwith\nnewlines'
+                userId: "user\nwith\nnewlines",
             };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithSpecialIds, ownerKeys.secretKey);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
-            expect(signedMember.groupMemberId).toContain('🚀');
+            expect(signedMember.groupMemberId).toContain("🚀");
         });
-        it('should handle empty string IDs', () => {
+        it("should handle empty string IDs", () => {
             const memberWithEmptyIds = {
                 ...testGroupMember,
-                groupMemberId: '',
-                groupId: '',
-                userId: ''
+                groupMemberId: "",
+                groupId: "",
+                userId: "",
             };
             const signedMember = (0, keys_1.addSignatureToObject)(memberWithEmptyIds, ownerKeys.secretKey);
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
-        it('should handle modification of existing group member', () => {
+        it("should handle modification of existing group member", () => {
             const originalMember = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Reader };
             const modifiedMember = { ...originalMember, role: group_permissions_1.GroupMemberRole.Writer };
             const signedMember = (0, keys_1.addSignatureToObject)(modifiedMember, adminKeys.secretKey);
@@ -195,17 +195,17 @@ describe('Group Members Signature Logic', () => {
             expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
         });
     });
-    describe('permission functions with role override', () => {
+    describe("permission functions with role override", () => {
         // Use the optional signerRole parameter to avoid mocking complexity
-        describe('signGroupMemberObject', () => {
-            it('should allow admin to sign group member', async () => {
+        describe("signGroupMemberObject", () => {
+            it("should allow admin to sign group member", async () => {
                 const memberToSign = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Writer };
                 const signedMember = await (0, keys_1.addSignatureToObject)(memberToSign, adminKeys.secretKey);
                 expect(signedMember.signature).toBeTruthy();
                 expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Writer);
                 expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
             });
-            it('should allow owner to sign group member', async () => {
+            it("should allow owner to sign group member", async () => {
                 const memberToSign = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
                 const signedMember = await (0, keys_1.addSignatureToObject)(memberToSign, ownerKeys.secretKey);
                 expect(signedMember.signature).toBeTruthy();
@@ -213,60 +213,60 @@ describe('Group Members Signature Logic', () => {
                 expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
             });
         });
-        describe('verifyGroupMemberSignature with role override', () => {
-            it('should verify valid signature with admin signer role', async () => {
+        describe("verifyGroupMemberSignature with role override", () => {
+            it("should verify valid signature with admin signer role", async () => {
                 const signedMember = (0, keys_1.addSignatureToObject)(testGroupMember, adminKeys.secretKey);
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(testGroupMember.groupId, signedMember, undefined, group_permissions_1.GroupMemberRole.Admin);
                 expect(isValid).toBe(true);
             });
-            it('should verify valid signature with owner signer role', async () => {
+            it("should verify valid signature with owner signer role", async () => {
                 const memberWithAdminRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
                 const signedMember = (0, keys_1.addSignatureToObject)(memberWithAdminRole, ownerKeys.secretKey);
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(memberWithAdminRole.groupId, signedMember, undefined, group_permissions_1.GroupMemberRole.Owner);
                 expect(isValid).toBe(true);
             });
-            it('should reject when signer role is below admin', async () => {
+            it("should reject when signer role is below admin", async () => {
                 const signedMember = (0, keys_1.addSignatureToObject)(testGroupMember, adminKeys.secretKey);
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(testGroupMember.groupId, signedMember, undefined, group_permissions_1.GroupMemberRole.Writer);
                 expect(isValid).toBe(false);
             });
-            it('should reject when signer role is below new member role', async () => {
+            it("should reject when signer role is below new member role", async () => {
                 const memberWithOwnerRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Owner };
                 const signedMember = (0, keys_1.addSignatureToObject)(memberWithOwnerRole, adminKeys.secretKey);
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(memberWithOwnerRole.groupId, signedMember, undefined, group_permissions_1.GroupMemberRole.Admin);
                 expect(isValid).toBe(false);
             });
-            it('should reject when signer role is below old member role', async () => {
+            it("should reject when signer role is below old member role", async () => {
                 const oldMember = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Owner };
                 const newMember = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Writer };
                 const signedNewMember = (0, keys_1.addSignatureToObject)(newMember, adminKeys.secretKey);
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(newMember.groupId, signedNewMember, oldMember, group_permissions_1.GroupMemberRole.Admin);
                 expect(isValid).toBe(false);
             });
-            it('should allow admin to modify reader role', async () => {
+            it("should allow admin to modify reader role", async () => {
                 const memberWithReaderRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Reader };
                 const signedMember = (0, keys_1.addSignatureToObject)(memberWithReaderRole, adminKeys.secretKey);
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(memberWithReaderRole.groupId, signedMember, undefined, group_permissions_1.GroupMemberRole.Admin);
                 expect(isValid).toBe(true);
             });
-            it('should allow owner to modify admin role', async () => {
+            it("should allow owner to modify admin role", async () => {
                 const memberWithAdminRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
                 const signedMember = (0, keys_1.addSignatureToObject)(memberWithAdminRole, ownerKeys.secretKey);
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(memberWithAdminRole.groupId, signedMember, undefined, group_permissions_1.GroupMemberRole.Owner);
                 expect(isValid).toBe(true);
             });
-            it('should reject invalid signature', async () => {
+            it("should reject invalid signature", async () => {
                 const signedMember = (0, keys_1.addSignatureToObject)(testGroupMember, adminKeys.secretKey);
-                signedMember.signature = 'invalid-signature';
+                signedMember.signature = "invalid-signature";
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(testGroupMember.groupId, signedMember, undefined, group_permissions_1.GroupMemberRole.Admin);
                 expect(isValid).toBe(false);
             });
-            it('should reject when signature is missing', async () => {
-                const memberWithoutSignature = { ...testGroupMember, signature: '' };
+            it("should reject when signature is missing", async () => {
+                const memberWithoutSignature = { ...testGroupMember, signature: "" };
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(testGroupMember.groupId, memberWithoutSignature, undefined, group_permissions_1.GroupMemberRole.Admin);
                 expect(isValid).toBe(false);
             });
-            it('should handle role modifications correctly', async () => {
+            it("should handle role modifications correctly", async () => {
                 const oldMember = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Writer };
                 const newMember = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
                 const signedNewMember = (0, keys_1.addSignatureToObject)(newMember, ownerKeys.secretKey);
@@ -274,7 +274,7 @@ describe('Group Members Signature Logic', () => {
                 const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(newMember.groupId, signedNewMember, oldMember, group_permissions_1.GroupMemberRole.Owner);
                 expect(isValid).toBe(true);
             });
-            it('should handle role demotion correctly', async () => {
+            it("should handle role demotion correctly", async () => {
                 const oldMember = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
                 const newMember = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Writer };
                 const signedNewMember = (0, keys_1.addSignatureToObject)(newMember, ownerKeys.secretKey);

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

@@ -1,6 +1,6 @@
-import { GroupMemberRole } from './group-member-roles';
-import type { IGroupMember } from './group-members';
-import type { IGroup } from './groups';
+import { GroupMemberRole } from "./group-member-roles";
+import type { IGroupMember } from "./group-members";
+import type { IGroup } from "./groups";
 export { GroupMemberRole };
 export declare function getUserRole(groupId: string, userId: string): Promise<GroupMemberRole>;
 export declare function getUserRoleFromPublicKey(groupId: string, publicKey: string): Promise<GroupMemberRole>;

package/dist/data/group-permissions.js

@@ -10,12 +10,12 @@ const keys_1 = require("../keys");
 const group_member_roles_1 = require("./group-member-roles");
 Object.defineProperty(exports, "GroupMemberRole", { enumerable: true, get: function () { return group_member_roles_1.GroupMemberRole; } });
 async function getUserRole(groupId, userId) {
-    const { Groups } = await Promise.resolve().then(() => require('./groups'));
-    const { GroupMembers } = await Promise.resolve().then(() => require('./group-members'));
+    const { Groups } = await Promise.resolve().then(() => require("./groups"));
+    const { GroupMembers } = await Promise.resolve().then(() => require("./group-members"));
     const userContext = await (0, context_1.getUserContext)();
     const groupDataContext = userContext.getDataContext(groupId);
-    const group = await Groups(groupDataContext).get(groupId)
-        || await Groups(userContext.userDataContext).get(groupId);
+    const group = (await Groups(groupDataContext).get(groupId)) ||
+        (await Groups(userContext.userDataContext).get(groupId));
     // If the group doesn't exist or the current user is explicitly the founder, return Founder role
     if (!group || group.founderUserId === userId) {
         return group_member_roles_1.GroupMemberRole.Founder;
@@ -27,11 +27,11 @@ async function getUserRole(groupId, userId) {
     return group.publicRole || group_member_roles_1.GroupMemberRole.None;
 }
 async function getUserRoleFromPublicKey(groupId, publicKey) {
-    const { Users } = await Promise.resolve().then(() => require('./users'));
+    const { Users } = await Promise.resolve().then(() => require("./users"));
     const userContext = await (0, context_1.getUserContext)();
     const groupDataContext = userContext.getDataContext(groupId);
-    const user = await Users(groupDataContext).findOne({ publicKey })
-        || await Users(userContext.userDataContext).findOne({ publicKey });
+    const user = (await Users(groupDataContext).findOne({ publicKey })) ||
+        (await Users(userContext.userDataContext).findOne({ publicKey }));
     if (user) {
         return getUserRole(groupId, user?.userId);
     }
@@ -39,13 +39,15 @@ async function getUserRoleFromPublicKey(groupId, publicKey) {
 }
 async function verifyGroupSignature(group, oldGroup) {
     (0, keys_1.verifyObjectSignature)(group);
-    const publicKey = (0, keys_1.getPublicKeyFromObjectSignature)(group) ?? '';
+    const publicKey = (0, keys_1.getPublicKeyFromObjectSignature)(group) ?? "";
     const signerRole = await getUserRoleFromPublicKey(group.groupId, publicKey);
-    if (oldGroup && oldGroup.founderUserId !== group.founderUserId && signerRole < group_member_roles_1.GroupMemberRole.Founder) {
-        throw new Error('Only group founders can change the founder of the group');
+    if (oldGroup &&
+        oldGroup.founderUserId !== group.founderUserId &&
+        signerRole < group_member_roles_1.GroupMemberRole.Founder) {
+        throw new Error("Only group founders can change the founder of the group");
     }
     if (signerRole < group_member_roles_1.GroupMemberRole.Admin) {
-        throw new Error('Only group admins can modify group settings');
+        throw new Error("Only group admins can modify group settings");
     }
 }
 async function isGroupMemberSignatureValid(groupId, newGroupMember, oldGroupMember, signerRole) {

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

@@ -1,5 +1,5 @@
-import { IGroupMember } from './group-members';
-import { IGroup } from './groups';
+import { type IGroupMember } from "./group-members";
+import { type IGroup } from "./groups";
 /**
  * Interface representing a shareable group with admin+ members
  */