@peers-app/peers-sdk 0.27.3 → 0.27.4

package/dist/data/package-versions.test.js

@@ -1,227 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteDB = require("better-sqlite3");
-const user_context_1 = require("../context/user-context");
-const user_context_singleton_1 = require("../context/user-context-singleton");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const group_member_roles_1 = require("./group-member-roles");
-const group_members_1 = require("./group-members");
-const groups_1 = require("./groups");
-const sql_data_source_1 = require("./orm/sql.data-source");
-const package_versions_1 = require("./package-versions");
-const users_1 = require("./users");
-// ---------------------------------------------------------------------------
-// In-memory SQLite harness (same pattern as sql.data-source.test.ts)
-// ---------------------------------------------------------------------------
-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;
-    }
-}
-// ---------------------------------------------------------------------------
-// Test fixtures
-// ---------------------------------------------------------------------------
-const writerKeys = (0, keys_1.newKeys)();
-const adminKeys = (0, keys_1.newKeys)();
-const testGroupId = (0, utils_1.newid)();
-const writerUserId = (0, utils_1.newid)();
-const adminUserId = (0, utils_1.newid)();
-function makePV(overrides = {}) {
-    return {
-        packageVersionId: (0, utils_1.newid)(),
-        packageId: (0, utils_1.newid)(),
-        version: "1.0.0",
-        versionTag: "dev",
-        packageVersionHash: "testhash",
-        packageBundleFileId: (0, utils_1.newid)(),
-        packageBundleFileHash: "bundlehash",
-        signature: "",
-        createdBy: writerUserId,
-        createdAt: new Date().toISOString(),
-        ...overrides,
-    };
-}
-// ---------------------------------------------------------------------------
-// Setup: create a real ephemeral UserContext with Users + GroupMembers seeded
-// so that getUserRoleFromPublicKey resolves Writer vs Admin from real data.
-// ---------------------------------------------------------------------------
-let userContext;
-beforeAll(async () => {
-    const db = new DBHarness();
-    const dataSourceFactory = (metaData, schema) => {
-        return new sql_data_source_1.SQLDataSource(db, metaData, schema);
-    };
-    userContext = new user_context_1.UserContext(writerUserId, dataSourceFactory, true);
-    await userContext.loadingPromise;
-    userContext.deviceId((0, utils_1.newid)());
-    (0, user_context_singleton_1.setUserContext)(userContext);
-    const dc = userContext.userDataContext;
-    // Enable passthrough so seeding skips signature checks on Groups/GroupMembers/Users
-    groups_1.GroupsTable.isPassthrough = true;
-    group_members_1.GroupMembersTable.isPassthrough = true;
-    users_1.UsersTable.isPassthrough = true;
-    // Seed the writer user
-    const { Users } = await Promise.resolve().then(() => require("./users"));
-    const writerUser = {
-        userId: writerUserId,
-        name: "Writer User",
-        publicKey: writerKeys.publicKey,
-        publicBoxKey: "",
-        signature: "",
-    };
-    await Users(dc).save(writerUser);
-    // Seed the admin user
-    const adminUser = {
-        userId: adminUserId,
-        name: "Admin User",
-        publicKey: adminKeys.publicKey,
-        publicBoxKey: "",
-        signature: "",
-    };
-    await Users(dc).save(adminUser);
-    // Seed a group so the group lookup finds real data (not "group not found → Founder")
-    const { Groups } = await Promise.resolve().then(() => require("./groups"));
-    await Groups(dc).save({
-        groupId: testGroupId,
-        name: "Test Group",
-        description: "",
-        founderUserId: (0, utils_1.newid)(), // different from writer/admin so nobody is auto-Founder
-        signature: "",
-        publicKey: "",
-        publicBoxKey: "",
-    });
-    // Seed group memberships with real roles
-    const { GroupMembers } = await Promise.resolve().then(() => require("./group-members"));
-    const writerMembership = {
-        groupMemberId: (0, utils_1.newid)(),
-        groupId: testGroupId,
-        userId: writerUserId,
-        role: group_member_roles_1.GroupMemberRole.Writer,
-        signature: "",
-    };
-    await GroupMembers(dc).save(writerMembership);
-    const adminMembership = {
-        groupMemberId: (0, utils_1.newid)(),
-        groupId: testGroupId,
-        userId: adminUserId,
-        role: group_member_roles_1.GroupMemberRole.Admin,
-        signature: "",
-    };
-    await GroupMembers(dc).save(adminMembership);
-    // Disable passthrough so the real permission checks apply during tests
-    groups_1.GroupsTable.isPassthrough = false;
-    group_members_1.GroupMembersTable.isPassthrough = false;
-    users_1.UsersTable.isPassthrough = false;
-    // Enable real signing
-    package_versions_1.PackageVersionsTable.enablePackageVersionSigning((pv) => (0, keys_1.addSignatureToObject)(pv, activeSecretKey));
-});
-let activeSecretKey = writerKeys.secretKey;
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("PackageVersionsTable.signAndSave — promotion permission enforcement", () => {
-    // These tests exercise the real signAndSave → save → verifyPackageVersionSignature
-    // chain against a real in-memory database with real group membership data.
-    //
-    // THE BUG: signAndSave previously called super.save() which skipped the
-    // overridden save() and its verifyPackageVersionSignature check. A Writer
-    // could promote dev → beta/stable unchallenged.
-    //
-    // THE FIX: signAndSave now calls this.save(), so the permission check fires.
-    // Helper: get the PackageVersions table in the test group context
-    function pvTable() {
-        const dc = userContext.getDataContext(testGroupId);
-        return (0, package_versions_1.PackageVersions)(dc);
-    }
-    describe("Writer role", () => {
-        beforeEach(() => {
-            activeSecretKey = writerKeys.secretKey;
-        });
-        it("can signAndSave a dev version", async () => {
-            const pv = makePV({ versionTag: "dev" });
-            const saved = await pvTable().signAndSave(pv);
-            expect(saved.versionTag).toBe("dev");
-            expect(saved.signature).toBeTruthy();
-        });
-        it("is blocked from signAndSave with versionTag=beta", async () => {
-            const pv = makePV({ versionTag: "beta" });
-            // Before the fix: this would PASS (super.save skipped the check)
-            // After the fix: this correctly REJECTS
-            await expect(pvTable().signAndSave(pv)).rejects.toThrow("Only group admins can create or update beta/stable package versions");
-        });
-        it("is blocked from signAndSave with versionTag=stable", async () => {
-            const pv = makePV({ versionTag: "stable" });
-            await expect(pvTable().signAndSave(pv)).rejects.toThrow("Only group admins can create or update beta/stable package versions");
-        });
-        it("is blocked from promoting an existing dev version to beta", async () => {
-            const pv = makePV({ versionTag: "dev" });
-            const saved = await pvTable().signAndSave(pv);
-            const promoted = { ...saved, versionTag: "beta" };
-            await expect(pvTable().signAndSave(promoted)).rejects.toThrow("Only group admins can create or update beta/stable package versions");
-        });
-    });
-    describe("Admin role", () => {
-        beforeEach(() => {
-            activeSecretKey = adminKeys.secretKey;
-        });
-        it("can signAndSave a dev version", async () => {
-            const pv = makePV({ versionTag: "dev" });
-            const saved = await pvTable().signAndSave(pv);
-            expect(saved.versionTag).toBe("dev");
-        });
-        it("can signAndSave a beta version", async () => {
-            const pv = makePV({ versionTag: "beta" });
-            const saved = await pvTable().signAndSave(pv);
-            expect(saved.versionTag).toBe("beta");
-        });
-        it("can signAndSave a stable version", async () => {
-            const pv = makePV({ versionTag: "stable" });
-            const saved = await pvTable().signAndSave(pv);
-            expect(saved.versionTag).toBe("stable");
-        });
-        it("can promote an existing dev version to beta", async () => {
-            const pv = makePV({ versionTag: "dev" });
-            const saved = await pvTable().signAndSave(pv);
-            const promoted = { ...saved, versionTag: "beta" };
-            const result = await pvTable().signAndSave(promoted);
-            expect(result.versionTag).toBe("beta");
-        });
-        it("can promote an existing beta version to stable", async () => {
-            const pv = makePV({ versionTag: "beta" });
-            const saved = await pvTable().signAndSave(pv);
-            const promoted = { ...saved, versionTag: "stable" };
-            const result = await pvTable().signAndSave(promoted);
-            expect(result.versionTag).toBe("stable");
-        });
-    });
-    describe("personal space (no group)", () => {
-        it("allows Writer to signAndSave any tag without restriction", async () => {
-            activeSecretKey = writerKeys.secretKey;
-            const dc = userContext.userDataContext;
-            const table = (0, package_versions_1.PackageVersions)(dc);
-            const pv = makePV({ versionTag: "stable" });
-            const saved = await table.signAndSave(pv);
-            expect(saved.versionTag).toBe("stable");
-        });
-    });
-});

package/dist/data/persistent-vars.conflict.test.d.ts

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

package/dist/data/persistent-vars.conflict.test.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const originalClientFlag = process.env.PEERS_IS_CLIENT;
-function createEventRegistry() {
-    return {
-        getEmitter: jest.fn().mockReturnValue({
-            event: { subscribe: jest.fn() },
-            emit: jest.fn(),
-        }),
-    };
-}
-function pvar(overrides) {
-    return {
-        name: "shared-name",
-        scope: "user",
-        value: { value: overrides.persistentVarId },
-        ...overrides,
-    };
-}
-afterEach(() => {
-    if (originalClientFlag === undefined) {
-        delete process.env.PEERS_IS_CLIENT;
-    }
-    else {
-        process.env.PEERS_IS_CLIENT = originalClientFlag;
-    }
-    jest.resetModules();
-});
-describe("PersistentVars unique-name conflict", () => {
-    async function table() {
-        delete process.env.PEERS_IS_CLIENT;
-        jest.resetModules();
-        let loaded;
-        await jest.isolateModulesAsync(async () => {
-            jest.doMock("../context/user-context-singleton", () => ({
-                getTableContainer: jest.fn(),
-                getUserContext: jest.fn(),
-            }));
-            const { PersistentVarsTable, persistentVarsMetaData } = await Promise.resolve().then(() => require("./persistent-vars"));
-            const { deterministicPvarId } = await Promise.resolve().then(() => require("../utils"));
-            loaded = {
-                deterministicPvarId,
-                vars: new PersistentVarsTable(persistentVarsMetaData, {
-                    dataSource: {},
-                    eventRegistry: createEventRegistry(),
-                }),
-            };
-        });
-        if (!loaded) {
-            throw new Error("PersistentVarsTable failed to load");
-        }
-        return loaded;
-    }
-    it("keeps the deterministic id and the newer value regardless of argument order", async () => {
-        const { deterministicPvarId, vars } = await table();
-        const legacy = pvar({
-            persistentVarId: "00mriijkhq94msfe9m2j6quwp",
-            value: { value: "from-legacy" },
-            modifiedAt: 20,
-            scope: "groupUser",
-            isSecret: true,
-        });
-        const deterministic = pvar({
-            persistentVarId: deterministicPvarId(legacy.name),
-            value: { value: "from-deterministic" },
-            modifiedAt: 10,
-        });
-        const forward = vars.resolveUniqueConflict(legacy, deterministic);
-        const reverse = vars.resolveUniqueConflict(deterministic, legacy);
-        expect(forward).toEqual(reverse);
-        expect(forward).toEqual({
-            loserId: legacy.persistentVarId,
-            winner: expect.objectContaining({
-                persistentVarId: deterministic.persistentVarId,
-                name: legacy.name,
-                scope: "groupUser",
-                isSecret: true,
-                value: { value: "from-legacy" },
-                modifiedAt: 20,
-            }),
-        });
-    });
-    it("keeps the identity winner's value when modifiedAt ties", async () => {
-        const { deterministicPvarId, vars } = await table();
-        const legacy = pvar({
-            persistentVarId: "00mriijkhq94msfe9m2j6quwp",
-            value: { value: "legacy-value" },
-            modifiedAt: 5,
-        });
-        const deterministic = pvar({
-            persistentVarId: deterministicPvarId(legacy.name),
-            value: { value: "deterministic-value" },
-            modifiedAt: 5,
-        });
-        expect(vars.resolveUniqueConflict(legacy, deterministic)?.winner.value).toEqual({
-            value: "deterministic-value",
-        });
-    });
-    it("uses the smaller id when neither record is deterministic", async () => {
-        const { vars } = await table();
-        const larger = pvar({
-            persistentVarId: "00mriijkhq94msfe9m2j6quwz",
-            value: { value: "larger-newer" },
-            modifiedAt: 9,
-        });
-        const smaller = pvar({
-            persistentVarId: "00mriijkhq94msfe9m2j6quwa",
-            value: { value: "smaller-older" },
-            modifiedAt: 1,
-        });
-        expect(vars.resolveUniqueConflict(larger, smaller)).toEqual({
-            loserId: larger.persistentVarId,
-            winner: expect.objectContaining({
-                persistentVarId: smaller.persistentVarId,
-                value: { value: "larger-newer" },
-                modifiedAt: 9,
-            }),
-        });
-    });
-    it("declines when the records are not two ids for one name", async () => {
-        const { vars } = await table();
-        const row = pvar({ persistentVarId: "00mriijkhq94msfe9m2j6quwp" });
-        expect(vars.resolveUniqueConflict(row, row)).toBeUndefined();
-        expect(vars.resolveUniqueConflict(row, pvar({ persistentVarId: "00mriijkhq94msfe9m2j6quwq", name: "other" }))).toBeUndefined();
-    });
-});

package/dist/data/persistent-vars.migration.test.d.ts

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

package/dist/data/persistent-vars.migration.test.js

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const originalClientFlag = process.env.PEERS_IS_CLIENT;
-function createEventRegistry() {
-    return {
-        getEmitter: jest.fn().mockReturnValue({
-            event: { subscribe: jest.fn() },
-            emit: jest.fn(),
-        }),
-    };
-}
-function createLegacyRecord(name) {
-    return {
-        persistentVarId: "00mriijkhq94msfe9m2j6quwp",
-        name,
-        scope: "device",
-        isSecret: true,
-        value: { value: "encrypted:ciphertext" },
-        modifiedAt: 1234,
-    };
-}
-afterEach(() => {
-    if (originalClientFlag === undefined) {
-        delete process.env.PEERS_IS_CLIENT;
-    }
-    else {
-        process.env.PEERS_IS_CLIENT = originalClientFlag;
-    }
-    jest.resetModules();
-    jest.restoreAllMocks();
-});
-describe("PersistentVars legacy ID migration", () => {
-    it("uses one custom table RPC from a renderer client", async () => {
-        process.env.PEERS_IS_CLIENT = "true";
-        jest.resetModules();
-        await jest.isolateModulesAsync(async () => {
-            jest.doMock("../context/user-context-singleton", () => ({
-                getTableContainer: jest.fn(),
-                getUserContext: jest.fn(),
-            }));
-            const { PersistentVarsTable, persistentVarsMetaData } = await Promise.resolve().then(() => require("./persistent-vars"));
-            const { ClientProxyDataSource } = await Promise.resolve().then(() => require("./orm/client-proxy.data-source"));
-            const { rpcServerCalls } = await Promise.resolve().then(() => require("../rpc-types"));
-            const record = createLegacyRecord("rendererMigration");
-            const migrated = { ...record, persistentVarId: "00mriijkhq94msfe9m2j6quwq" };
-            const tableMethodCall = jest.fn().mockResolvedValue(migrated);
-            rpcServerCalls.tableMethodCall = tableMethodCall;
-            const dataContextId = "00mriijkhq94msfe9m2j6qabc";
-            const table = new PersistentVarsTable(persistentVarsMetaData, {
-                dataSource: new ClientProxyDataSource(persistentVarsMetaData, undefined, dataContextId),
-                eventRegistry: createEventRegistry(),
-            });
-            await expect(table.migrateLegacyId(record)).resolves.toEqual(migrated);
-            expect(tableMethodCall).toHaveBeenCalledTimes(1);
-            expect(tableMethodCall).toHaveBeenCalledWith(dataContextId, "PersistentVars", "migrateLegacyId", record);
-        });
-    });
-    it("removes a legacy duplicate when the canonical record already exists", async () => {
-        delete process.env.PEERS_IS_CLIENT;
-        jest.resetModules();
-        await jest.isolateModulesAsync(async () => {
-            jest.doMock("../context/user-context-singleton", () => ({
-                getTableContainer: jest.fn(),
-                getUserContext: jest.fn(),
-            }));
-            const { PersistentVarsTable, persistentVarsMetaData } = await Promise.resolve().then(() => require("./persistent-vars"));
-            const { deterministicPvarId } = await Promise.resolve().then(() => require("../utils"));
-            const legacy = createLegacyRecord("existingCanonical");
-            const canonical = {
-                ...legacy,
-                persistentVarId: deterministicPvarId(legacy.name),
-                value: { value: "encrypted:canonical" },
-            };
-            const deleteRecord = jest.fn().mockResolvedValue(undefined);
-            const save = jest.fn();
-            const table = new PersistentVarsTable(persistentVarsMetaData, {
-                dataSource: {
-                    tableName: "PersistentVars",
-                    primaryKeyName: "persistentVarId",
-                    get: jest.fn().mockResolvedValue(canonical),
-                    list: jest.fn(),
-                    count: jest.fn(),
-                    save,
-                    insert: jest.fn(),
-                    update: jest.fn(),
-                    delete: deleteRecord,
-                },
-                eventRegistry: createEventRegistry(),
-            });
-            await expect(table.migrateLegacyId(legacy)).resolves.toEqual(canonical);
-            expect(deleteRecord).toHaveBeenCalledWith(legacy);
-            expect(save).not.toHaveBeenCalled();
-        });
-    });
-    it("restores the legacy record when writing the canonical ID fails", async () => {
-        delete process.env.PEERS_IS_CLIENT;
-        jest.resetModules();
-        await jest.isolateModulesAsync(async () => {
-            jest.doMock("../context/user-context-singleton", () => ({
-                getTableContainer: jest.fn(),
-                getUserContext: jest.fn(),
-            }));
-            const { PersistentVarsTable, persistentVarsMetaData } = await Promise.resolve().then(() => require("./persistent-vars"));
-            const legacy = createLegacyRecord("rollbackMigration");
-            const migrationError = new Error("canonical write failed");
-            const deleteRecord = jest.fn().mockResolvedValue(undefined);
-            const save = jest.fn().mockRejectedValueOnce(migrationError).mockResolvedValueOnce(legacy);
-            const table = new PersistentVarsTable(persistentVarsMetaData, {
-                dataSource: {
-                    tableName: "PersistentVars",
-                    primaryKeyName: "persistentVarId",
-                    get: jest.fn().mockResolvedValue(undefined),
-                    list: jest.fn(),
-                    count: jest.fn(),
-                    save,
-                    insert: jest.fn(),
-                    update: jest.fn(),
-                    delete: deleteRecord,
-                },
-                eventRegistry: createEventRegistry(),
-            });
-            await expect(table.migrateLegacyId(legacy)).rejects.toBe(migrationError);
-            expect(deleteRecord).toHaveBeenCalledWith(legacy);
-            expect(save).toHaveBeenCalledTimes(2);
-            expect(save.mock.calls[0][0]).toMatchObject({
-                name: legacy.name,
-                value: legacy.value,
-            });
-            expect(save.mock.calls[0][0].persistentVarId).not.toBe(legacy.persistentVarId);
-            expect(save.mock.calls[1][0]).toEqual(legacy);
-        });
-    });
-});

package/dist/data/persistent-vars.package-scope.test.d.ts

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

package/dist/data/persistent-vars.package-scope.test.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
-const persistent_var_identity_1 = require("./persistent-var-identity");
-describe("package-scoped persistent variable identity", () => {
-    test("prefixes package identity before deterministic ID generation", () => {
-        const packageId = (0, utils_1.newid)();
-        const physicalName = (0, persistent_var_identity_1.packageScopedPersistentVarStorageName)(packageId, "settings", "device", (0, utils_1.newid)());
-        expect(physicalName).toBe(`${packageId}_settings`);
-        expect((0, utils_1.deterministicPvarId)(physicalName)).not.toBe((0, utils_1.deterministicPvarId)("settings"));
-    });
-    test("qualifies group-dependent scopes with the trusted context", () => {
-        const packageId = (0, utils_1.newid)();
-        const dataContextId = (0, utils_1.newid)();
-        const baseName = (0, persistent_var_identity_1.packageScopedPersistentVarName)(packageId, "thread:dynamic");
-        expect((0, persistent_var_identity_1.persistentVarStorageName)(baseName, "device", dataContextId)).toBe(baseName);
-        expect((0, persistent_var_identity_1.persistentVarStorageName)(baseName, "user", dataContextId)).toBe(baseName);
-        expect((0, persistent_var_identity_1.persistentVarStorageName)(baseName, "group", dataContextId)).toBe(baseName);
-        expect((0, persistent_var_identity_1.persistentVarStorageName)(baseName, "groupDevice", dataContextId)).toBe(`${baseName}_${dataContextId}`);
-        expect((0, persistent_var_identity_1.persistentVarStorageName)(baseName, "groupUser", dataContextId)).toBe(`${baseName}_${dataContextId}`);
-    });
-    test("rejects invalid identity inputs", () => {
-        expect(() => (0, persistent_var_identity_1.packageScopedPersistentVarName)("not-an-id", "settings")).toThrow(/package ID/);
-        expect(() => (0, persistent_var_identity_1.packageScopedPersistentVarName)((0, utils_1.newid)(), " ")).toThrow(/non-empty/);
-        expect(() => (0, persistent_var_identity_1.persistentVarStorageName)("settings", "groupUser")).toThrow(/data context/);
-    });
-});

package/dist/data/sync-recovery-queue.test.d.ts

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