@peers-app/peers-sdk 0.23.9 → 0.23.10

package/dist/context/user-context-singleton.js

@@ -135,12 +135,27 @@ function getAllTables() {
     return tableMap;
 }
 if (!rpc_types_1.isClient) {
+    /**
+     * Resolve a table for a renderer RPC call.
+     *
+     * Prefers a full (code/package-registered) instance. When no package on this
+     * device has registered `tableName`, falls back to a synced
+     * `TableDefinitions` record so a renderer whose UI bundle is ahead of the
+     * package the host loaded can still reach the table's data.
+     */
     async function getTable(dataContextId, tableName) {
         const userContext = await getUserContext();
-        const table = userContext
-            .getDataContext(dataContextId || userContext.userId)
-            .tableContainer.getTable(tableName);
-        return table;
+        const tableContainer = userContext.getDataContext(dataContextId || userContext.userId).tableContainer;
+        try {
+            return tableContainer.getTable(tableName);
+        }
+        catch (err) {
+            const fallback = await tableContainer.getFallbackTable(tableName);
+            if (fallback) {
+                return fallback;
+            }
+            throw err;
+        }
     }
     // TODO: add check that client has permission to make this call
     rpc_types_1.rpcServerCalls.tableMethodCall = async (dataContextId, tableName, methodName, ...args) => {

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

@@ -123,12 +123,20 @@ export declare function groupVar<T = string>(name: string, opts?: Omit<IPersiste
 /**
  * A persistent variable that is stored only on this device, in the user's personal db.
  * It can have a different value for each group on the device but is not synced to other devices.
+ *
+ * The record always lives in the personal db. `opts.dataContext` (or, when omitted, the
+ * current default group) only selects which group's value is addressed by suffixing the
+ * stored name with that data context id, so server-side callers that pin a group and
+ * renderer callers that follow the default group share one row.
  */
 export declare function groupDeviceVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, "scope">): PersistentVar<T>;
 export declare function groupDeviceVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, "scope">): PersistentVar<T | undefined>;
 /**
  * A persistent variable that is stored in the user's personal db and synced across all their devices in the group.
  * It can have a different value for each user in the group and a different value for each group the user is in.
+ *
+ * As with {@link groupDeviceVar}, the record always lives in the personal db; `opts.dataContext`
+ * only selects the group whose value is addressed.
  */
 export declare function groupUserVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, "scope">): PersistentVar<T>;
 export declare function groupUserVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, "scope">): PersistentVar<T | undefined>;

package/dist/data/persistent-vars.js

@@ -277,26 +277,71 @@ function persistentVarFactory(name, opts) {
         void (async () => {
             try {
                 const userContext = opts?.userContext || (await (0, user_context_singleton_1.getUserContext)());
-                function getDataContext() {
-                    if (opts?.dataContext) {
-                        return opts.dataContext;
-                    }
+                /**
+                 * The data context whose `PersistentVars` table stores this variable.
+                 *
+                 * Only `group` scope lives in a group DB. Every other scope lives in the
+                 * user's personal DB; for `groupDevice` / `groupUser` the route context
+                 * (`opts.dataContext` or the current default group) only disambiguates
+                 * the stored name (see {@link getVarNameInDb}). Storing the record in
+                 * the personal DB regardless of whether a caller pinned a `dataContext`
+                 * keeps server-side callers (which pin) and renderer callers (which
+                 * don't) reading and writing the same row.
+                 */
+                function getStorageDataContext() {
                     if (scope === "group") {
-                        return userContext.defaultDataContext();
+                        return opts?.dataContext ?? userContext.defaultDataContext();
+                    }
+                    return userContext.userDataContext;
+                }
+                /**
+                 * Before storage was unified in the personal DB, a `groupDevice` /
+                 * `groupUser` var created with an explicit group `dataContext` was
+                 * written to that group's DB. Return that legacy location so an
+                 * existing value can be migrated forward, or `undefined` when there is
+                 * no distinct legacy location for this variable.
+                 */
+                function getLegacyStorageDataContext() {
+                    if (scope !== "groupDevice" && scope !== "groupUser") {
+                        return undefined;
                     }
-                    else {
-                        return userContext.userDataContext;
+                    const pinned = opts?.dataContext;
+                    if (!pinned || pinned.dataContextId === userContext.userDataContext.dataContextId) {
+                        return undefined;
                     }
+                    return pinned;
                 }
                 function getVarNameInDb() {
                     const dc = opts?.dataContext || userContext.defaultDataContext();
                     return (0, persistent_var_identity_1.persistentVarStorageName)(name, scope, dc?.dataContextId);
                 }
+                /**
+                 * Copy a record left in a group DB by the pre-unification storage rule
+                 * into the personal DB. Secrets are skipped because their ciphertext is
+                 * bound to the group key and cannot be moved verbatim. The legacy row is
+                 * left in place: older builds on other devices may still read it, and
+                 * the personal copy is authoritative from here on.
+                 */
+                async function migrateLegacyRec(table, name) {
+                    const legacyContext = getLegacyStorageDataContext();
+                    if (!legacyContext) {
+                        return undefined;
+                    }
+                    const legacyRec = await PersistentVars(legacyContext).findOne({ name });
+                    if (!legacyRec || legacyRec.scope !== scope || legacyRec.isSecret) {
+                        return undefined;
+                    }
+                    const { persistentVarId: _legacyId, ...rest } = legacyRec;
+                    return table.save({ ...rest, persistentVarId: "" }, { weakInsert: true });
+                }
                 async function loadRecFromDb() {
-                    const dc = getDataContext();
+                    const dc = getStorageDataContext();
                     const table = PersistentVars(dc);
                     const name = getVarNameInDb();
                     let dbRec = await table.findOne({ name });
+                    if (!dbRec) {
+                        dbRec = await migrateLegacyRec(table, name);
+                    }
                     if (dbRec) {
                         if (dbRec.scope !== scope) {
                             console.warn(`${name}: deleting old persistent var record because scopes don't match.  If this is unexpected there could be two different persistent variables using the same name`);
@@ -340,7 +385,7 @@ function persistentVarFactory(name, opts) {
                         return;
                     }
                     rec.value.value = value;
-                    const dc = getDataContext();
+                    const dc = getStorageDataContext();
                     const table = PersistentVars(dc);
                     try {
                         rec = await table.save(rec, { weakInsert: true });
@@ -362,7 +407,7 @@ function persistentVarFactory(name, opts) {
                     }
                 }
                 deleteVarImpl = async () => {
-                    const dc = getDataContext();
+                    const dc = getStorageDataContext();
                     const table = PersistentVars(dc);
                     if (rec?.persistentVarId) {
                         await table.delete(rec);
@@ -374,7 +419,7 @@ function persistentVarFactory(name, opts) {
                 };
                 // subscribe to db changes
                 userContext.subscribeToDataChangedAcrossAllGroups(exports.persistentVarsMetaData.name, async (evt) => {
-                    const dc = getDataContext();
+                    const dc = getStorageDataContext();
                     if (dc && evt.dataContext && evt.dataContext.dataContextId !== dc.dataContextId) {
                         return;
                     }

package/dist/data/tool-access-approvals.d.ts

@@ -50,8 +50,8 @@ export declare const toolAccessApprovalSchema: z.ZodObject<{
     userId: string;
     expiresAt: Date;
     toolId: string;
-    createdAt: Date;
     dataContextId: string;
+    createdAt: Date;
     toolAccessApprovalId: string;
     toolName: string;
     argsHash: string;
@@ -106,8 +106,8 @@ export declare function ToolAccessApprovals(dataContext?: DataContext): import("
     userId: string;
     expiresAt: Date;
     toolId: string;
-    createdAt: Date;
     dataContextId: string;
+    createdAt: Date;
     toolAccessApprovalId: string;
     toolName: string;
     argsHash: string;

package/package.json

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