@peers-app/peers-sdk 0.23.1 → 0.23.4

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

@@ -1,3 +1,4 @@
+import type { UserContext } from "../context/user-context";
 import { type IGroupMember } from "./group-members";
 import { type IGroup } from "./groups";
 /**
@@ -16,6 +17,18 @@ export interface IGroupShare {
  * @throws Error if group not found or user lacks permission
  */
 export declare function generateGroupShare(groupId: string): Promise<IGroupShare>;
+/**
+ * Write a group record and missing membership rows into the group's data context.
+ *
+ * Uses the lowest data source so bootstrap can seed already-signed rows without
+ * re-running table permission checks. Existing memberships for the same user
+ * are left in place so retries can repair a partial import.
+ *
+ * @param userContext - Joiner or importer whose group context should be seeded
+ * @param groupShare - Canonical group plus Admin+ memberships
+ * @param extraMembers - Additional signed rows such as a newly approved Reader
+ */
+export declare function seedGroupContextFromShare(userContext: UserContext, groupShare: Pick<IGroupShare, "group" | "groupMembers">, extraMembers?: IGroupMember[]): Promise<void>;
 /**
  * Validates that an object has the correct GroupShare structure
  * @param obj Object to validate

package/dist/data/group-share.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateGroupShare = generateGroupShare;
+exports.seedGroupContextFromShare = seedGroupContextFromShare;
 exports.validateGroupShare = validateGroupShare;
 exports.estimateGroupShareSize = estimateGroupShareSize;
 exports.checkQRCodeCompatibility = checkQRCodeCompatibility;
@@ -57,7 +58,7 @@ async function importGroupShare(groupShareJson) {
         throw new Error("Invalid GroupShare structure");
     }
     const userContext = await (0, user_context_singleton_1.getUserContext)();
-    const { group, groupMembers } = groupShare;
+    const { group } = groupShare;
     // Check if group already exists
     const existingGroup = await (0, groups_1.Groups)(userContext.userDataContext).get(group.groupId);
     if (existingGroup) {
@@ -65,19 +66,42 @@ async function importGroupShare(groupShareJson) {
     }
     // Save group to user's groups table
     await (0, groups_1.Groups)(userContext.userDataContext).save(group, { restoreIfDeleted: true });
-    // Get group data context for the new group
+    await seedGroupContextFromShare(userContext, groupShare);
+    return group.groupId;
+}
+/**
+ * Write a group record and missing membership rows into the group's data context.
+ *
+ * Uses the lowest data source so bootstrap can seed already-signed rows without
+ * re-running table permission checks. Existing memberships for the same user
+ * are left in place so retries can repair a partial import.
+ *
+ * @param userContext - Joiner or importer whose group context should be seeded
+ * @param groupShare - Canonical group plus Admin+ memberships
+ * @param extraMembers - Additional signed rows such as a newly approved Reader
+ */
+async function seedGroupContextFromShare(userContext, groupShare, extraMembers = []) {
+    const { group, groupMembers } = groupShare;
     const groupDataContext = userContext.getDataContext(group.groupId);
-    // Save the group data to the group's own context
     const groupsTable = (0, groups_1.Groups)(groupDataContext);
-    const groupsTableDataSource = getLowestDataSource(groupsTable);
-    await groupsTableDataSource.save(group);
-    // Save all admin members as seed data for device recognition
+    await getLowestDataSource(groupsTable).save(group);
     const groupMembersTable = (0, group_members_1.GroupMembers)(groupDataContext);
     const groupMembersDataSource = getLowestDataSource(groupMembersTable);
-    for (const member of groupMembers) {
+    const seenUserIds = new Set();
+    for (const member of [...groupMembers, ...extraMembers]) {
+        if (!member?.userId || member.groupId !== group.groupId || seenUserIds.has(member.userId)) {
+            continue;
+        }
+        seenUserIds.add(member.userId);
+        const existing = await groupMembersTable.findOne({
+            groupId: group.groupId,
+            userId: member.userId,
+        });
+        if (existing) {
+            continue;
+        }
         await groupMembersDataSource.save(member);
     }
-    return group.groupId;
 }
 /**
  * Validates that an object has the correct GroupShare structure

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

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

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

@@ -0,0 +1,110 @@
+"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/group-invite/group-invite.types.d.ts

@@ -5,6 +5,8 @@
  * password. Multiple admins can listen for the same password simultaneously.
  */
 import type { GroupMemberRole } from "../data/group-member-roles";
+import type { IGroupMember } from "../data/group-members";
+import type { IGroupShare } from "../data/group-share";
 /**
  * Information about a group shared during the invitation flow.
  */
@@ -69,16 +71,24 @@ export interface IGroupJoinApprovalInfo {
     approved: boolean;
     /** The role assigned to the new member (if approved) */
     role?: GroupMemberRole;
-    /** Group share data for initial sync (if approved) */
-    groupShare?: {
-        group: any;
-        groupMembers: any[];
-    };
+    /** Canonical group record plus Admin+ seed memberships */
+    groupShare?: IGroupShare;
+    /** Newly signed membership for the joiner, including Reader roles */
+    newMember?: IGroupMember;
     /** Admin's user info for adding to contacts */
     adminInfo?: IGroupJoinRequestInfo;
     /** Error message if rejected */
     rejectionReason?: string;
 }
+/**
+ * Signal that a joiner finished importing approval data and can connect to the admin.
+ */
+export interface IGroupInviteJoinFinished {
+    /** Group the joiner just imported */
+    groupId: string;
+    /** Approving admin device that should be contacted in that group context */
+    adminDeviceId: string;
+}
 /**
  * Active invitation listener state.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.23.1",
+  "version": "0.23.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"