@peers-app/peers-sdk 0.27.3 → 0.27.5

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

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

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

@@ -1,336 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const group_members_1 = require("./group-members");
-const group_permissions_1 = require("./group-permissions");
-// Test the group members signature logic directly without ORM dependencies
-describe("Group Members Signature Logic", () => {
-    let testGroupMember;
-    let ownerKeys;
-    let adminKeys;
-    beforeEach(() => {
-        ownerKeys = (0, keys_1.newKeys)();
-        adminKeys = (0, keys_1.newKeys)();
-        testGroupMember = {
-            groupMemberId: "test-member-1",
-            groupId: "test-group-1",
-            userId: "test-user-1",
-            role: group_permissions_1.GroupMemberRole.Reader,
-            signature: "",
-        };
-    });
-    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.groupId).toBe(testGroupMember.groupId);
-            expect(signedGroupMember.userId).toBe(testGroupMember.userId);
-            expect(signedGroupMember.role).toBe(testGroupMember.role);
-        });
-        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", () => {
-            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", () => {
-            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", () => {
-        // 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", () => {
-            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", () => {
-            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", () => {
-            const memberWithAdminRole = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
-            const signedMember = (0, keys_1.addSignatureToObject)(memberWithAdminRole, adminKeys.secretKey);
-            expect(signedMember.signature).toBeTruthy();
-            expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Admin);
-            expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
-        });
-    });
-    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", () => {
-            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", () => {
-            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", () => {
-            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)", () => {
-            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", () => {
-            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", () => {
-            const signedMember = (0, keys_1.addSignatureToObject)(testGroupMember, ownerKeys.secretKey);
-            // Tamper with signature by adding extra characters
-            signedMember.signature = `${signedMember.signature}tampered`;
-            expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(false);
-        });
-        it("should detect empty signature", () => {
-            testGroupMember.signature = "";
-            expect((0, keys_1.isObjectSignatureValid)(testGroupMember)).toBe(false);
-        });
-        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";
-            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", () => {
-            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,
-            ];
-            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", () => {
-            const memberWithDifferentIds = {
-                ...testGroupMember,
-                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");
-        });
-    });
-    describe("edge cases", () => {
-        it("should handle long IDs", () => {
-            const memberWithLongIds = {
-                ...testGroupMember,
-                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", () => {
-            const memberWithSpecialIds = {
-                ...testGroupMember,
-                groupMemberId: "member-🚀-test",
-                groupId: 'group-"with"-quotes',
-                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("🚀");
-        });
-        it("should handle empty string IDs", () => {
-            const memberWithEmptyIds = {
-                ...testGroupMember,
-                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", () => {
-            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);
-            expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Writer);
-            expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
-        });
-    });
-    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 () => {
-                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 () => {
-                const memberToSign = { ...testGroupMember, role: group_permissions_1.GroupMemberRole.Admin };
-                const signedMember = await (0, keys_1.addSignatureToObject)(memberToSign, ownerKeys.secretKey);
-                expect(signedMember.signature).toBeTruthy();
-                expect(signedMember.role).toBe(group_permissions_1.GroupMemberRole.Admin);
-                expect((0, keys_1.isObjectSignatureValid)(signedMember)).toBe(true);
-            });
-        });
-        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 () => {
-                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 () => {
-                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 () => {
-                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 () => {
-                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 () => {
-                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 () => {
-                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 () => {
-                const signedMember = (0, keys_1.addSignatureToObject)(testGroupMember, adminKeys.secretKey);
-                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: "" };
-                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 () => {
-                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);
-                // Owner can promote writer to admin
-                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 () => {
-                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);
-                // Owner can demote admin to writer
-                const isValid = await (0, group_permissions_1.isGroupMemberSignatureValid)(newMember.groupId, signedNewMember, oldMember, group_permissions_1.GroupMemberRole.Owner);
-                expect(isValid).toBe(true);
-            });
-        });
-    });
-});
-describe("GroupMembersTable.resolveUniqueConflict", () => {
-    const groupId = (0, utils_1.newid)();
-    const userId = (0, utils_1.newid)();
-    const resolve = (incoming, existing) => group_members_1.GroupMembersTable.prototype.resolveUniqueConflict.call({}, incoming, existing);
-    const row = (groupMemberId, overrides = {}) => ({
-        groupMemberId,
-        groupId,
-        userId,
-        role: group_permissions_1.GroupMemberRole.Writer,
-        signature: `sig-${groupMemberId}`,
-        ...overrides,
-    });
-    it("keeps the smaller id, unchanged, whichever row arrives", () => {
-        const [low, high] = [(0, utils_1.newid)(), (0, utils_1.newid)()].sort();
-        const a = row(low);
-        const b = row(high);
-        expect(resolve(a, b)).toEqual({ winner: a, loserId: high });
-        expect(resolve(b, a)).toEqual({ winner: a, loserId: high });
-        expect(resolve(b, a)?.winner.signature).toBe(`sig-${low}`);
-    });
-    it("prefers the id derived from the group and user", () => {
-        const derived = row((0, utils_1.deterministicGroupMemberId)(groupId, userId));
-        const other = row("00000000000000000000000001");
-        expect(resolve(other, derived)).toEqual({ winner: derived, loserId: other.groupMemberId });
-        expect(resolve(derived, other)).toEqual({ winner: derived, loserId: other.groupMemberId });
-    });
-    it("leaves rows that grant different access for a person to settle", () => {
-        const a = row((0, utils_1.newid)());
-        expect(resolve(a, row((0, utils_1.newid)(), { role: group_permissions_1.GroupMemberRole.Admin }))).toBeUndefined();
-        expect(resolve(a, row((0, utils_1.newid)(), { deleted: true }))).toBeUndefined();
-        expect(resolve(a, row((0, utils_1.newid)(), { userId: (0, utils_1.newid)() }))).toBeUndefined();
-        expect(resolve(a, row((0, utils_1.newid)(), { groupId: (0, utils_1.newid)() }))).toBeUndefined();
-        expect(resolve(a, { ...a })).toBeUndefined();
-    });
-    it("treats a missing deleted flag as not deleted", () => {
-        const a = row((0, utils_1.newid)());
-        const b = row((0, utils_1.newid)(), { deleted: false });
-        expect(resolve(a, b)).toBeDefined();
-    });
-    it("depends only on the two signed rows and never modifies either one", () => {
-        const a = Object.freeze(row((0, utils_1.newid)()));
-        const b = Object.freeze(row((0, utils_1.newid)()));
-        const before = [structuredClone(a), structuredClone(b)];
-        expect(resolve(a, b)).toEqual(resolve(b, a));
-        expect([a, b]).toEqual(before);
-    });
-});

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

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

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

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteDB = require("better-sqlite3");
-const user_context_1 = require("../context/user-context");
-const utils_1 = require("../utils");
-const group_member_roles_1 = require("./group-member-roles");
-const group_members_1 = require("./group-members");
-const group_share_1 = require("./group-share");
-const groups_1 = require("./groups");
-const sql_data_source_1 = require("./orm/sql.data-source");
-class DBHarness {
-    _db = null;
-    get db() {
-        if (!this._db) {
-            this._db = new SQLiteDB(":memory:");
-            this._db.pragma("journal_mode = WAL");
-        }
-        return this._db;
-    }
-    async get(sql, params = []) {
-        return this.db.prepare(sql).get(params);
-    }
-    async all(sql, params = []) {
-        return this.db.prepare(sql).all(params);
-    }
-    async exec(sql, params = []) {
-        const result = this.db.prepare(sql).run(params);
-        return { changes: result.changes };
-    }
-    async close() {
-        this._db?.close();
-        this._db = null;
-    }
-}
-describe("seedGroupContextFromShare", () => {
-    const dbs = new Map();
-    let userContext;
-    const userId = (0, utils_1.newid)();
-    beforeAll(async () => {
-        groups_1.GroupsTable.isPassthrough = true;
-        group_members_1.GroupMembersTable.isPassthrough = true;
-        const dataSourceFactory = (metaData, schema, groupId) => {
-            const key = groupId || userId;
-            let db = dbs.get(key);
-            if (!db) {
-                db = new DBHarness();
-                dbs.set(key, db);
-            }
-            return new sql_data_source_1.SQLDataSource(db, metaData, schema);
-        };
-        userContext = new user_context_1.UserContext(userId, dataSourceFactory, true);
-        await userContext.loadingPromise;
-        userContext.deviceId((0, utils_1.newid)());
-    });
-    afterAll(async () => {
-        groups_1.GroupsTable.isPassthrough = false;
-        group_members_1.GroupMembersTable.isPassthrough = false;
-        userContext.dispose();
-        await Promise.all([...dbs.values()].map((db) => db.close()));
-    });
-    function makeGroup() {
-        return {
-            groupId: (0, utils_1.newid)(),
-            name: "Home",
-            description: "",
-            founderUserId: (0, utils_1.newid)(),
-            signature: "group-sig",
-            publicKey: "pk",
-            publicBoxKey: "pbk",
-        };
-    }
-    function makeMember(groupId, memberUserId, role) {
-        return {
-            groupMemberId: (0, utils_1.newid)(),
-            groupId,
-            userId: memberUserId,
-            role,
-            signature: "member-sig",
-        };
-    }
-    it("seeds the group record and missing memberships, including extra Reader rows", async () => {
-        const group = makeGroup();
-        const admin = makeMember(group.groupId, (0, utils_1.newid)(), group_member_roles_1.GroupMemberRole.Admin);
-        const joiner = makeMember(group.groupId, userId, group_member_roles_1.GroupMemberRole.Reader);
-        await (0, group_share_1.seedGroupContextFromShare)(userContext, { group, groupMembers: [admin] }, [joiner]);
-        const groupContext = userContext.getDataContext(group.groupId);
-        await expect((0, groups_1.Groups)(groupContext).get(group.groupId)).resolves.toMatchObject({
-            name: "Home",
-        });
-        await expect((0, group_members_1.GroupMembers)(groupContext).findOne({ userId: admin.userId, groupId: group.groupId })).resolves.toMatchObject({ role: group_member_roles_1.GroupMemberRole.Admin });
-        await expect((0, group_members_1.GroupMembers)(groupContext).findOne({ userId: userId, groupId: group.groupId })).resolves.toMatchObject({ role: group_member_roles_1.GroupMemberRole.Reader });
-    });
-    it("leaves existing memberships in place on a retry", async () => {
-        const group = makeGroup();
-        const admin = makeMember(group.groupId, (0, utils_1.newid)(), group_member_roles_1.GroupMemberRole.Admin);
-        await (0, group_share_1.seedGroupContextFromShare)(userContext, { group, groupMembers: [admin] });
-        const replacement = {
-            ...admin,
-            groupMemberId: (0, utils_1.newid)(),
-            signature: "other-sig",
-        };
-        await (0, group_share_1.seedGroupContextFromShare)(userContext, { group, groupMembers: [replacement] });
-        const saved = await (0, group_members_1.GroupMembers)(userContext.getDataContext(group.groupId)).findOne({
-            userId: admin.userId,
-            groupId: group.groupId,
-        });
-        expect(saved?.groupMemberId).toBe(admin.groupMemberId);
-        expect(saved?.signature).toBe("member-sig");
-    });
-});

package/dist/data/groups.test.d.ts

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

package/dist/data/groups.test.js

@@ -1,153 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keys_1 = require("../keys");
-const group_member_roles_1 = require("./group-member-roles");
-// Test the signature logic directly without full ORM dependencies
-describe("Groups Signature Logic", () => {
-    let testGroup;
-    let ownerKeys;
-    let adminKeys;
-    let unauthorizedKeys;
-    beforeEach(() => {
-        ownerKeys = (0, keys_1.newKeys)();
-        adminKeys = (0, keys_1.newKeys)();
-        unauthorizedKeys = (0, keys_1.newKeys)();
-        testGroup = {
-            groupId: "test-group-1",
-            name: "Test Group",
-            description: "A test group",
-            publicRole: group_member_roles_1.GroupMemberRole.Reader,
-            disabled: false,
-            signature: "",
-            founderUserId: "",
-            publicKey: ownerKeys.publicKey,
-            publicBoxKey: ownerKeys.publicKey,
-        };
-    });
-    describe("basic signature functionality", () => {
-        it("should add signature to group object", () => {
-            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
-            expect(signedGroup.signature).toBeTruthy();
-            expect(signedGroup.signature).toContain(":");
-            expect(signedGroup.name).toBe(testGroup.name);
-            expect(signedGroup.groupId).toBe(testGroup.groupId);
-        });
-        it("should verify valid signature", () => {
-            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
-            const isValid = (0, keys_1.isObjectSignatureValid)(signedGroup);
-            expect(isValid).toBe(true);
-        });
-        it("should reject invalid signature after modification", () => {
-            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
-            // Modify the group after signing
-            signedGroup.name = "Modified Name";
-            const isValid = (0, keys_1.isObjectSignatureValid)(signedGroup);
-            expect(isValid).toBe(false);
-        });
-        it("should extract correct public key from signature", () => {
-            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
-            const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroup);
-            expect(extractedKey).toBe(ownerKeys.publicKey);
-        });
-    });
-    describe("basic signing with different keys", () => {
-        it("should create valid signature with owner key", () => {
-            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
-            const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroup);
-            expect(extractedKey).toBe(ownerKeys.publicKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
-        });
-        it("should create valid signature with admin key", () => {
-            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, adminKeys.secretKey);
-            const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroup);
-            expect(extractedKey).toBe(adminKeys.publicKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
-        });
-        it("should create valid signature with any key", () => {
-            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, unauthorizedKeys.secretKey);
-            const extractedKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedGroup);
-            expect(extractedKey).toBe(unauthorizedKeys.publicKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true); // Signature is cryptographically valid
-        });
-    });
-    describe("signature tampering detection", () => {
-        it("should detect tampered signature", () => {
-            const signedGroup = (0, keys_1.addSignatureToObject)(testGroup, ownerKeys.secretKey);
-            // Tamper with signature by adding extra characters
-            signedGroup.signature = `${signedGroup.signature}tampered`;
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(false);
-        });
-        it("should detect empty signature", () => {
-            testGroup.signature = "";
-            expect((0, keys_1.isObjectSignatureValid)(testGroup)).toBe(false);
-        });
-        it("should detect malformed signature", () => {
-            testGroup.signature = "malformed-signature";
-            expect((0, keys_1.isObjectSignatureValid)(testGroup)).toBe(false);
-        });
-        it("should handle signature without colon separator", () => {
-            testGroup.signature = "noseparator";
-            expect((0, keys_1.isObjectSignatureValid)(testGroup)).toBe(false);
-            expect((0, keys_1.getPublicKeyFromObjectSignature)(testGroup)).toBeUndefined();
-        });
-    });
-    describe("complex group objects", () => {
-        it("should handle groups with all optional fields", () => {
-            const complexGroup = {
-                ...testGroup,
-                publicRole: group_member_roles_1.GroupMemberRole.Writer,
-                disabled: true,
-            };
-            const signedGroup = (0, keys_1.addSignatureToObject)(complexGroup, ownerKeys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
-            expect(signedGroup.publicRole).toBe(group_member_roles_1.GroupMemberRole.Writer);
-            expect(signedGroup.disabled).toBe(true);
-        });
-        it("should handle groups without optional fields", () => {
-            const simpleGroup = {
-                groupId: testGroup.groupId,
-                name: testGroup.name,
-                description: testGroup.description,
-                signature: "",
-                founderUserId: "",
-                publicKey: ownerKeys.publicKey,
-                publicBoxKey: ownerKeys.publicKey,
-            };
-            const signedGroup = (0, keys_1.addSignatureToObject)(simpleGroup, ownerKeys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
-            expect(signedGroup.publicRole).toBeUndefined();
-            expect(signedGroup.disabled).toBeUndefined();
-        });
-    });
-    describe("edge cases", () => {
-        it("should handle long group names and descriptions", () => {
-            const longGroup = {
-                ...testGroup,
-                name: "A".repeat(1000),
-                description: "B".repeat(5000),
-            };
-            const signedGroup = (0, keys_1.addSignatureToObject)(longGroup, ownerKeys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
-        });
-        it("should handle special characters in group data", () => {
-            const specialGroup = {
-                ...testGroup,
-                name: 'Group with 🚀 emojis and "quotes" & <html>',
-                description: "Contains\nnewlines\tand\ttabs",
-            };
-            const signedGroup = (0, keys_1.addSignatureToObject)(specialGroup, ownerKeys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
-            expect(signedGroup.name).toContain("🚀");
-            expect(signedGroup.description).toContain("\n");
-        });
-        it("should handle empty strings", () => {
-            const emptyGroup = {
-                ...testGroup,
-                name: "",
-                description: "",
-            };
-            const signedGroup = (0, keys_1.addSignatureToObject)(emptyGroup, ownerKeys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedGroup)).toBe(true);
-        });
-    });
-});

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

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