@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/invites/group-approval.test.d.ts

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

package/dist/invites/group-approval.test.js

@@ -1,223 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteDB = require("better-sqlite3");
-const user_context_1 = require("../context/user-context");
-const devices_1 = require("../data/devices");
-const group_member_roles_1 = require("../data/group-member-roles");
-const group_members_1 = require("../data/group-members");
-const group_secret_1 = require("../data/group-secret");
-const groups_1 = require("../data/groups");
-const sql_data_source_1 = require("../data/orm/sql.data-source");
-const persistent_vars_1 = require("../data/persistent-vars");
-const users_1 = require("../data/users");
-const keys_1 = require("../keys");
-const rpc_types_1 = require("../rpc-types");
-const utils_1 = require("../utils");
-const group_approval_1 = require("./group-approval");
-const invite_messages_1 = require("./invite-messages");
-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;
-    }
-}
-/** One in-memory user with its own personal and group databases. */
-async function makeUser(name) {
-    const dbs = new Map();
-    const keys = (0, keys_1.newKeys)();
-    const userId = (0, utils_1.newid)();
-    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);
-    };
-    const userContext = new user_context_1.UserContext(userId, dataSourceFactory, true);
-    await userContext.loadingPromise;
-    const deviceId = (0, utils_1.newid)();
-    userContext.deviceId(deviceId);
-    await (0, users_1.Users)(userContext.userDataContext).save({
-        userId,
-        name,
-        publicKey: keys.publicKey,
-        publicBoxKey: keys.publicBoxKey,
-    });
-    return {
-        userId,
-        deviceId,
-        keys,
-        userContext,
-        dispose: async () => {
-            userContext.dispose();
-            await Promise.all([...dbs.values()].map((db) => db.close()));
-        },
-    };
-}
-describe("group approval payloads", () => {
-    let admin;
-    let joiner;
-    let group;
-    let groupKeys;
-    const originalEncrypt = rpc_types_1.rpcServerCalls.encryptData;
-    beforeAll(async () => {
-        groups_1.GroupsTable.isPassthrough = true;
-        group_members_1.GroupMembersTable.isPassthrough = true;
-        users_1.UsersTable.isPassthrough = true;
-        admin = await makeUser("Alice");
-        joiner = await makeUser("Bob");
-        group_members_1.GroupMembersTable.enableGroupMemberSigning((member) => (0, keys_1.addSignatureToObject)(member, admin.keys.secretKey));
-        groupKeys = (0, keys_1.newKeys)();
-        group = {
-            groupId: (0, utils_1.newid)(),
-            name: "Family",
-            description: "",
-            founderUserId: admin.userId,
-            signature: "group-sig",
-            publicKey: groupKeys.publicKey,
-            publicBoxKey: groupKeys.publicBoxKey,
-        };
-        await (0, groups_1.Groups)(admin.userContext.userDataContext).save(group);
-        await (0, group_members_1.GroupMembers)(admin.userContext.getDataContext(group.groupId)).signAndSave({
-            groupMemberId: (0, utils_1.newid)(),
-            groupId: group.groupId,
-            userId: admin.userId,
-            role: group_member_roles_1.GroupMemberRole.Owner,
-            signature: "",
-        });
-        // The secret pvar is stored encrypted with the owning user's secret key.
-        await (0, persistent_vars_1.PersistentVars)(admin.userContext.userDataContext).save({
-            persistentVarId: "",
-            name: (0, group_secret_1.groupSecretKeyPvarName)(group.groupId),
-            scope: "groupUser",
-            isSecret: false,
-            value: { value: (0, keys_1.encryptData)(groupKeys.secretKey, admin.keys.secretKey) },
-        });
-        await (0, devices_1.Devices)(admin.userContext.userDataContext).save({
-            deviceId: admin.deviceId,
-            userId: admin.userId,
-            name: "Alice laptop",
-            firstSeen: new Date(),
-            lastSeen: new Date(),
-            trustLevel: 100,
-        });
-    });
-    afterAll(async () => {
-        groups_1.GroupsTable.isPassthrough = false;
-        group_members_1.GroupMembersTable.isPassthrough = false;
-        users_1.UsersTable.isPassthrough = false;
-        rpc_types_1.rpcServerCalls.encryptData = originalEncrypt;
-        await admin.dispose();
-        await joiner.dispose();
-    });
-    it("builds an approval the joiner can import, including the boxed group secret", async () => {
-        const approval = await (0, group_approval_1.buildGroupApproval)(admin.userContext, {
-            groupId: group.groupId,
-            joiner: {
-                userId: joiner.userId,
-                publicKey: joiner.keys.publicKey,
-                publicBoxKey: joiner.keys.publicBoxKey,
-                displayName: "Bob",
-            },
-            role: group_member_roles_1.GroupMemberRole.Writer,
-            approverKeys: admin.keys,
-            approverDeviceId: admin.deviceId,
-        });
-        expect(() => invite_messages_1.groupApprovalSchema.parse(approval)).not.toThrow();
-        expect(approval.membership).toMatchObject({
-            userId: joiner.userId,
-            role: group_member_roles_1.GroupMemberRole.Writer,
-        });
-        expect(approval.membership.signature).toContain(":");
-        // Each of the approver's devices writes the same row for this join.
-        expect(approval.membership.groupMemberId).toBe((0, utils_1.deterministicGroupMemberId)(group.groupId, joiner.userId));
-        expect(approval.seed.groupMembers.map((member) => member.userId)).toContain(admin.userId);
-        expect(approval.seed.devices[0]).toMatchObject({
-            deviceId: admin.deviceId,
-            deviceName: "Alice laptop",
-        });
-        expect(JSON.stringify(approval)).not.toContain(groupKeys.secretKey);
-        // The joiner side re-encrypts the secret with its own key when saving the pvar.
-        rpc_types_1.rpcServerCalls.encryptData = async (value) => (0, keys_1.encryptData)(value, joiner.keys.secretKey);
-        const result = await (0, group_approval_1.importGroupApproval)(joiner.userContext, approval, joiner.keys);
-        expect(result).toEqual({
-            groupId: group.groupId,
-            approverUserId: admin.userId,
-            approverDeviceId: admin.deviceId,
-        });
-        await expect((0, groups_1.Groups)(joiner.userContext.userDataContext).get(group.groupId)).resolves.toMatchObject({ name: "Family" });
-        const joinerGroupContext = joiner.userContext.getDataContext(group.groupId);
-        await expect((0, group_members_1.GroupMembers)(joinerGroupContext).findOne({ userId: joiner.userId, groupId: group.groupId })).resolves.toMatchObject({ role: group_member_roles_1.GroupMemberRole.Writer });
-        await expect((0, group_members_1.GroupMembers)(joinerGroupContext).findOne({ userId: admin.userId, groupId: group.groupId })).resolves.toMatchObject({ role: group_member_roles_1.GroupMemberRole.Owner });
-        await expect((0, users_1.Users)(joiner.userContext.userDataContext).get(admin.userId)).resolves.toMatchObject({ name: "Alice" });
-        await expect((0, group_secret_1.readGroupSecretKey)(joiner.userContext, group.groupId, joiner.keys.secretKey)).resolves.toBe(groupKeys.secretKey);
-    });
-    it("rejects approvals addressed to someone else or with a mismatched box sender", async () => {
-        const approval = await (0, group_approval_1.buildGroupApproval)(admin.userContext, {
-            groupId: group.groupId,
-            joiner: {
-                userId: joiner.userId,
-                publicKey: joiner.keys.publicKey,
-                publicBoxKey: joiner.keys.publicBoxKey,
-            },
-            role: group_member_roles_1.GroupMemberRole.Reader,
-            approverKeys: admin.keys,
-            approverDeviceId: admin.deviceId,
-        });
-        const stranger = await makeUser("Carol");
-        try {
-            await expect((0, group_approval_1.importGroupApproval)(stranger.userContext, approval, stranger.keys)).rejects.toThrow("different user");
-        }
-        finally {
-            await stranger.dispose();
-        }
-        await expect((0, group_approval_1.importGroupApproval)(joiner.userContext, {
-            ...approval,
-            boxedSecret: { ...approval.boxedSecret, fromPublicKey: (0, keys_1.newKeys)().publicBoxKey },
-        }, joiner.keys)).rejects.toThrow("inconsistent");
-    });
-    it("refuses to approve from a non-admin or to grant above the approver's role", async () => {
-        await expect((0, group_approval_1.buildGroupApproval)(joiner.userContext, {
-            groupId: group.groupId,
-            joiner: {
-                userId: (0, utils_1.newid)(),
-                publicKey: (0, keys_1.newKeys)().publicKey,
-                publicBoxKey: (0, keys_1.newKeys)().publicBoxKey,
-            },
-            role: group_member_roles_1.GroupMemberRole.Reader,
-            approverKeys: joiner.keys,
-            approverDeviceId: joiner.deviceId,
-        })).rejects.toThrow();
-        await expect((0, group_approval_1.buildGroupApproval)(admin.userContext, {
-            groupId: group.groupId,
-            joiner: {
-                userId: (0, utils_1.newid)(),
-                publicKey: (0, keys_1.newKeys)().publicKey,
-                publicBoxKey: (0, keys_1.newKeys)().publicBoxKey,
-            },
-            role: group_member_roles_1.GroupMemberRole.Founder,
-            approverKeys: admin.keys,
-            approverDeviceId: admin.deviceId,
-        })).rejects.toThrow("higher than your own");
-    });
-});

package/dist/invites/invite-token.test.d.ts

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

package/dist/invites/invite-token.test.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const group_member_roles_1 = require("../data/group-member-roles");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const invite_messages_1 = require("./invite-messages");
-const invite_token_1 = require("./invite-token");
-function identity(keys = (0, keys_1.newKeys)()) {
-    return {
-        userId: (0, utils_1.newid)(),
-        publicKey: keys.publicKey,
-        publicBoxKey: keys.publicBoxKey,
-        displayName: "Alice",
-        secretKey: keys.secretKey,
-    };
-}
-function contactToken(inviter = identity(), expiresAt = new Date(Date.now() + 60_000)) {
-    const { secretKey, ...publicIdentity } = inviter;
-    return (0, invite_token_1.createInviteToken)({
-        type: "contact",
-        inviter: publicIdentity,
-        expiresAt: expiresAt.toISOString(),
-        nonce: (0, invite_token_1.newInviteNonce)(),
-        epoch: 0,
-        uses: 1,
-    }, secretKey);
-}
-describe("PeersInvite tokens", () => {
-    it("round-trips through every shareable encoding and verifies the signature", () => {
-        const token = contactToken();
-        const encoded = (0, invite_token_1.encodeInviteToken)(token);
-        expect((0, invite_token_1.parseInviteToken)(encoded)).toEqual(token);
-        expect((0, invite_token_1.parseInviteToken)((0, invite_token_1.inviteUrl)(token))).toEqual(token);
-        expect((0, invite_token_1.parseInviteToken)((0, invite_token_1.inviteDeepLink)(token))).toEqual(token);
-        expect((0, invite_token_1.parseInviteToken)(`https://peers.app/?app#invite=${encoded}`)).toEqual(token);
-        expect((0, invite_token_1.parseInviteToken)(`  ${encoded}\n`)).toEqual(token);
-        expect((0, invite_token_1.extractInviteTokenText)((0, invite_token_1.inviteUrl)(token))).toBe(encoded);
-    });
-    it("rejects tampered contents without echoing the input", () => {
-        const token = contactToken();
-        const tampered = (0, invite_token_1.encodeInviteToken)({ ...token, epoch: token.epoch + 1 });
-        expect(() => (0, invite_token_1.parseInviteToken)(tampered)).toThrow("Invite signature is not valid");
-        expect(() => (0, invite_token_1.parseInviteToken)("not a token")).toThrow("not a valid Peers invite");
-    });
-    it("refuses to sign with a key that is not the inviter's", () => {
-        const inviter = identity();
-        const { secretKey: _ignored, ...publicIdentity } = inviter;
-        expect(() => (0, invite_token_1.createInviteToken)({
-            type: "contact",
-            inviter: publicIdentity,
-            expiresAt: new Date(Date.now() + 1000).toISOString(),
-            nonce: (0, invite_token_1.newInviteNonce)(),
-            epoch: 0,
-            uses: 1,
-        }, (0, keys_1.newKeys)().secretKey)).toThrow("inviter's own key");
-    });
-    it("enforces expiry and type expectations", () => {
-        const expired = contactToken(identity(), new Date(Date.now() - 1000));
-        const encoded = (0, invite_token_1.encodeInviteToken)(expired);
-        expect(() => (0, invite_token_1.parseInviteToken)(encoded)).toThrow("expired");
-        expect((0, invite_token_1.parseInviteToken)(encoded, { allowExpired: true })).toEqual(expired);
-        expect(() => (0, invite_token_1.parseInviteToken)(encoded, { allowExpired: true, expectType: "group" })).toThrow("Expected a group invite");
-    });
-    it("requires group facts exactly when the type is group", () => {
-        const inviter = identity();
-        const { secretKey, ...publicIdentity } = inviter;
-        const base = {
-            inviter: publicIdentity,
-            expiresAt: new Date(Date.now() + 1000).toISOString(),
-            nonce: (0, invite_token_1.newInviteNonce)(),
-            epoch: 0,
-            uses: "unlimited",
-        };
-        expect(() => (0, invite_token_1.createInviteToken)({ ...base, type: "group" }, secretKey)).toThrow();
-        const groupKeys = (0, keys_1.newKeys)();
-        const token = (0, invite_token_1.createInviteToken)({
-            ...base,
-            type: "group",
-            group: {
-                groupId: (0, utils_1.newid)(),
-                name: "Family",
-                publicKey: groupKeys.publicKey,
-                publicBoxKey: groupKeys.publicBoxKey,
-                role: group_member_roles_1.GroupMemberRole.Reader,
-                mode: "open",
-            },
-        }, secretKey);
-        expect((0, invite_token_1.parseInviteToken)((0, invite_token_1.encodeInviteToken)(token), { expectType: "group" }).group?.mode).toBe("open");
-    });
-});
-describe("invite envelopes", () => {
-    it("seals to the recipient and exposes the verified sender keys", () => {
-        const sender = identity();
-        const recipient = identity();
-        const message = invite_messages_1.contactReplySchema.parse({
-            kind: "contact-reply",
-            inviteNonce: (0, invite_token_1.newInviteNonce)(),
-            inviteEpoch: 0,
-            responder: {
-                userId: sender.userId,
-                publicKey: sender.publicKey,
-                publicBoxKey: sender.publicBoxKey,
-            },
-            responderDeviceId: (0, utils_1.newid)(),
-        });
-        const envelope = (0, invite_messages_1.sealInviteEnvelope)(message, {
-            publicKey: sender.publicKey,
-            publicBoxKey: sender.publicBoxKey,
-            secretKey: sender.secretKey,
-        }, { userId: recipient.userId, publicBoxKey: recipient.publicBoxKey });
-        expect(envelope.to).toBe(recipient.userId);
-        expect(JSON.stringify(envelope)).not.toContain(sender.userId);
-        const opened = (0, invite_messages_1.openInviteEnvelope)(envelope, {
-            userId: recipient.userId,
-            secretKey: recipient.secretKey,
-        });
-        expect(opened.message).toEqual(message);
-        expect(opened.senderPublicKey).toBe(sender.publicKey);
-        expect(opened.senderPublicBoxKey).toBe(sender.publicBoxKey);
-        expect(() => (0, invite_messages_1.openInviteEnvelope)(envelope, { userId: (0, utils_1.newid)(), secretKey: recipient.secretKey })).toThrow("different user");
-        expect(() => (0, invite_messages_1.openInviteEnvelope)(envelope, { userId: recipient.userId, secretKey: (0, keys_1.newKeys)().secretKey })).toThrow();
-    });
-});

package/dist/keys.test.d.ts

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