@peers-app/peers-sdk 0.1.4

package/dist/data/peer-events/peer-event-handlers.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { DataContext } from "../../context/data-context";
+export declare const peerEventHandlerSchema: z.ZodObject<{
+    peerEventHandlerId: z.ZodString;
+    peerEventTypeId: z.ZodString;
+    handlerWorkflowId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    peerEventTypeId: string;
+    peerEventHandlerId: string;
+    handlerWorkflowId: string;
+}, {
+    peerEventTypeId: string;
+    peerEventHandlerId: string;
+    handlerWorkflowId: string;
+}>;
+export type IPeerEventHandler = z.infer<typeof peerEventHandlerSchema>;
+export declare function PeerEventHandlers(dataContext?: DataContext): import("../orm").Table<{
+    peerEventTypeId: string;
+    peerEventHandlerId: string;
+    handlerWorkflowId: string;
+}>;

package/dist/data/peer-events/peer-event-handlers.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.peerEventHandlerSchema = void 0;
+exports.PeerEventHandlers = PeerEventHandlers;
+const zod_1 = require("zod");
+const types_1 = require("../orm/types");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+exports.peerEventHandlerSchema = zod_1.z.object({
+    peerEventHandlerId: zod_1.z.string(),
+    peerEventTypeId: zod_1.z.string().describe('The event type that will be handled'),
+    handlerWorkflowId: zod_1.z.string().describe('The workflow that will be triggered when this event occurs'),
+});
+const metaData = {
+    name: 'PeerEventHandlers',
+    description: 'The handlers registered for peer events',
+    primaryKeyName: 'peerEventHandlerId',
+    fields: (0, types_1.schemaToFields)(exports.peerEventHandlerSchema),
+    indexes: [
+        {
+            fields: ['peerEventTypeId'],
+        },
+    ],
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.peerEventHandlerSchema);
+function PeerEventHandlers(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.peerEventHandlerSchema);
+}

package/dist/data/peer-events/peer-event-types.d.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+import type { DataContext } from "../../context/data-context";
+export declare const peerEventTypeSchema: z.ZodObject<{
+    peerEventTypeId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    schema: z.ZodObject<{
+        type: z.ZodNativeEnum<typeof import("../tools").IOSchemaType>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodNativeEnum<typeof import("../..").FieldType>;
+            defaultValue: z.ZodOptional<z.ZodAny>;
+            optional: z.ZodOptional<z.ZodBoolean>;
+            isArray: z.ZodOptional<z.ZodBoolean>;
+            subType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }, {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: import("../tools").IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    }, {
+        type: import("../tools").IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    }>;
+    cronSchedule: z.ZodOptional<z.ZodString>;
+    nextScheduledTime: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    schema: {
+        type: import("../tools").IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    };
+    peerEventTypeId: string;
+    createdAt: Date;
+    cronSchedule?: string | undefined;
+    nextScheduledTime?: number | undefined;
+}, {
+    name: string;
+    description: string;
+    schema: {
+        type: import("../tools").IOSchemaType;
+        fields?: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[] | undefined;
+    };
+    peerEventTypeId: string;
+    createdAt?: Date | undefined;
+    cronSchedule?: string | undefined;
+    nextScheduledTime?: number | undefined;
+}>;
+export type IPeerEventType = z.infer<typeof peerEventTypeSchema>;
+export declare function PeerEventTypes(dataContext?: DataContext): import("../orm").Table<{
+    name: string;
+    description: string;
+    schema: {
+        type: import("../tools").IOSchemaType;
+        fields: {
+            name: string;
+            type: import("../..").FieldType;
+            optional?: boolean | undefined;
+            description?: string | undefined;
+            defaultValue?: any;
+            isArray?: boolean | undefined;
+            subType?: string | undefined;
+        }[];
+    };
+    peerEventTypeId: string;
+    createdAt: Date;
+    cronSchedule?: string | undefined;
+    nextScheduledTime?: number | undefined;
+}>;

package/dist/data/peer-events/peer-event-types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.peerEventTypeSchema = void 0;
+exports.PeerEventTypes = PeerEventTypes;
+const types_1 = require("../orm/types");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+const zod_1 = require("zod");
+const tools_1 = require("../tools");
+exports.peerEventTypeSchema = zod_1.z.object({
+    peerEventTypeId: zod_1.z.string(),
+    name: zod_1.z.string().describe('The name of the event'),
+    description: zod_1.z.string().describe('The description of the event type and what it represents'),
+    createdAt: zod_1.z.date().default(() => new Date()).describe('The date the event type was created'),
+    schema: tools_1.ioSchema.describe('The schema of the event data'),
+    cronSchedule: zod_1.z.string().optional().describe('The cron schedule for this event'),
+    nextScheduledTime: zod_1.z.number().optional().describe('The next time this event is scheduled to run based on the cron schedule'),
+});
+const metaData = {
+    name: 'PeerEventTypes',
+    description: 'The types of events that are possible in this Peers network, what their schemas are, and what tools will be triggered, etc.',
+    primaryKeyName: 'peerEventTypeId',
+    fields: (0, types_1.schemaToFields)(exports.peerEventTypeSchema),
+    iconClassName: 'bi bi-lightning-charge-fill',
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.peerEventTypeSchema);
+function PeerEventTypes(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.peerEventTypeSchema);
+}

package/dist/data/peer-events/peer-events.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { DataContext } from "../../context/data-context";
+export declare const peerEventSchema: z.ZodObject<{
+    peerEventId: z.ZodEffects<z.ZodString, string, string>;
+    peerEventTypeId: z.ZodEffects<z.ZodString, string, string>;
+    parentMessageId: z.ZodEffects<z.ZodString, string, string>;
+    eventData: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    workflowRunsTriggered: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    peerEventTypeId: string;
+    createdAt: Date;
+    parentMessageId: string;
+    peerEventId: string;
+    eventData: {} & {
+        [k: string]: any;
+    };
+    workflowRunsTriggered?: string[] | undefined;
+}, {
+    peerEventTypeId: string;
+    parentMessageId: string;
+    peerEventId: string;
+    eventData: {} & {
+        [k: string]: any;
+    };
+    createdAt?: Date | undefined;
+    workflowRunsTriggered?: string[] | undefined;
+}>;
+type _IEvent = z.infer<typeof peerEventSchema>;
+export interface IPeerEvent<T = Record<string, any>> extends Omit<_IEvent, "eventData"> {
+    eventData: T;
+}
+export interface IEmitPeerEventArgs {
+    peerEventTypeId: string;
+    eventData: Record<string, any>;
+    channelOrThreadId?: string;
+    assistantId?: string;
+}
+export declare function PeerEvents(dataContext?: DataContext): import("../..").Table<IPeerEvent<Record<string, any>>>;
+export declare function emitPeerEvent<T extends Record<string, any>>(args: IEmitPeerEventArgs): Promise<IPeerEvent<T>>;
+export {};

package/dist/data/peer-events/peer-events.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.peerEventSchema = void 0;
+exports.PeerEvents = PeerEvents;
+exports.emitPeerEvent = emitPeerEvent;
+const zod_1 = require("zod");
+const mentions_1 = require("../../mentions");
+const zod_types_1 = require("../../types/zod-types");
+const utils_1 = require("../../utils");
+const messages_1 = require("../messages");
+const types_1 = require("../orm/types");
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const table_definitions_system_1 = require("../orm/table-definitions.system");
+const users_1 = require("../users");
+const workflow_runs_1 = require("../workflow-runs");
+const peer_event_handlers_1 = require("./peer-event-handlers");
+const peer_event_types_1 = require("./peer-event-types");
+const __1 = require("../..");
+exports.peerEventSchema = zod_1.z.object({
+    peerEventId: zod_types_1.zodPeerId,
+    peerEventTypeId: zod_types_1.zodPeerId.describe('The type of event'),
+    parentMessageId: zod_types_1.zodPeerId.describe('The message that this event will be emitted in the context of'),
+    eventData: zod_types_1.zodAnyObject.describe('The data of the event as defined by the event type schema'),
+    createdAt: zod_1.z.date().default(() => new Date()).describe('The date the event was created'),
+    workflowRunsTriggered: zod_1.z.string().array().optional().describe('The workflows that were triggered by this event'),
+});
+const metaData = {
+    name: 'PeerEvents',
+    description: 'The events that have occurred in the Peers network',
+    primaryKeyName: 'peerEventId',
+    fields: (0, types_1.schemaToFields)(exports.peerEventSchema),
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.peerEventSchema);
+function PeerEvents(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.peerEventSchema);
+}
+async function emitPeerEvent(args) {
+    const { peerEventTypeId, channelOrThreadId: groupOrChannelId } = args;
+    let { eventData } = args;
+    const eventType = await (0, peer_event_types_1.PeerEventTypes)().get(peerEventTypeId);
+    if (!eventType) {
+        throw new Error(`Event type ${peerEventTypeId} not found`);
+    }
+    const schema = (0, types_1.fieldsToSchema)(eventType.schema.fields);
+    const defaults = {};
+    for (const field of eventType.schema.fields) {
+        const zodField = schema.shape[field.name];
+        const value = zodField.safeParse(eventData[field.name]);
+        if (value.success) {
+            defaults[field.name] = value.data;
+        }
+    }
+    eventData = {
+        ...defaults,
+        ...eventData
+    };
+    schema.parse(eventData);
+    const me = await (0, users_1.getMe)();
+    const channelOrThreadId = groupOrChannelId || me.userId;
+    const assistantId = args.assistantId
+        || (await (0, __1.getPrimaryAssistant)()).assistantId
+        || __1.defaultAssistantId;
+    const peerEventId = (0, utils_1.newid)();
+    const eventMention = (0, mentions_1.formatMention)({ kind: 'event', id: peerEventTypeId, name: eventType.name });
+    // TODO get better link to event instance
+    const eventLink = ''; //`[logs](#events/${peerEventTypeId})`;
+    const handlers = await (0, peer_event_handlers_1.PeerEventHandlers)().list({ peerEventTypeId });
+    let handlerStr = '';
+    if (handlers.length === 0) {
+        handlerStr = 'No handlers subscribed to this event type';
+    }
+    else if (handlers.length === 1) {
+        handlerStr = `triggering 1 handler`;
+    }
+    else {
+        handlerStr = `triggering ${handlers.length} handlers`;
+    }
+    const eventMessage = await (0, messages_1.sendMessage)({
+        channelOrThreadIdOrWorkflowRunId: channelOrThreadId,
+        messageContent: `Emitting ${eventMention} ${eventLink} - ${handlerStr}`,
+        assistantId,
+    });
+    const event = {
+        peerEventId,
+        peerEventTypeId,
+        eventData: eventData,
+        createdAt: new Date(),
+        parentMessageId: eventMessage.messageId,
+    };
+    await PeerEvents().insert(event);
+    for (const handler of handlers) {
+        const workflowId = handler.handlerWorkflowId;
+        (0, workflow_runs_1.runWorkflow)({
+            workflowId,
+            parentMessageIdOrChannelIdOrGroupId: eventMessage.messageId,
+            vars: {
+                ...eventData
+            }
+        });
+    }
+    return event;
+}

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

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { Observable } from "../observable";
+import { Table } from "./orm/table";
+import { ITableMetaData } from "./orm/types";
+import type { DataContext } from "../context/data-context";
+import { UserContext } from "../context";
+import { ISaveOptions } from "./orm";
+declare const schema: z.ZodObject<{
+    persistentVarId: z.ZodString;
+    name: z.ZodString;
+    scope: z.ZodEnum<["device", "user", "group", "groupDevice", "groupUser"]>;
+    value: z.ZodObject<{
+        value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        value?: any;
+    }, {
+        value?: any;
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    userCreated: z.ZodOptional<z.ZodBoolean>;
+    isSecret: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    value: {
+        value?: any;
+    };
+    persistentVarId: string;
+    scope: "user" | "group" | "device" | "groupDevice" | "groupUser";
+    description?: string | undefined;
+    userCreated?: boolean | undefined;
+    isSecret?: boolean | undefined;
+}, {
+    name: string;
+    value: {
+        value?: any;
+    };
+    persistentVarId: string;
+    scope: "user" | "group" | "device" | "groupDevice" | "groupUser";
+    description?: string | undefined;
+    userCreated?: boolean | undefined;
+    isSecret?: boolean | undefined;
+}>;
+export declare const persistentVarsMetaData: ITableMetaData;
+export type IPersistentVar = z.infer<typeof schema>;
+export declare class PersistentVarsTable extends Table<IPersistentVar> {
+    insert(persistentVar: IPersistentVar): Promise<IPersistentVar>;
+    update(persistentVar: IPersistentVar): Promise<IPersistentVar>;
+    save(persistentVar: IPersistentVar, opts?: ISaveOptions): Promise<IPersistentVar>;
+    getPersistentVarValue<T>(name: string): Promise<T | undefined>;
+}
+export declare function PersistentVars(dataContext?: DataContext): PersistentVarsTable;
+export type PersistentVar<T> = Observable<T> & {
+    loadingPromise: Promise<PersistentVar<T>>;
+};
+export declare function getPersistentVar(name: string, dataContext?: DataContext): Promise<IPersistentVar | undefined>;
+interface IPersistentVarOptions<T> {
+    scope?: 'device' | 'user' | 'group' | 'groupDevice' | 'groupUser';
+    defaultValue?: T;
+    userContext?: UserContext;
+    dataContext?: DataContext;
+    dbValue?: T;
+    isSecret?: boolean;
+}
+/**
+ * A persistent variable that is stored only on this device, in the user's personal db
+ */
+export declare function deviceVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope' | 'dataContext'>): PersistentVar<T>;
+/**
+ * A persistent variable that is stored in the user's personal db and synced across all their devices
+ */
+export declare function userVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope' | 'dataContext'>): PersistentVar<T>;
+/**
+ * A persistent variable that is shared by all users in a group. It is stored in the group's db and synced across all users and devices in the group.
+ * It can have a different value for each group on the device.
+ */
+export declare function groupVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope'>): PersistentVar<T>;
+/**
+ * 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.
+ */
+export declare function groupDeviceVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope'>): PersistentVar<T>;
+/**
+ * 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.
+ */
+export declare function groupUserVar<T = string>(name: string, opts?: Omit<IPersistentVarOptions<T>, 'scope'>): PersistentVar<T>;
+export {};

package/dist/data/persistent-vars.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentVarsTable = exports.persistentVarsMetaData = void 0;
+exports.PersistentVars = PersistentVars;
+exports.getPersistentVar = getPersistentVar;
+exports.deviceVar = deviceVar;
+exports.userVar = userVar;
+exports.groupVar = groupVar;
+exports.groupDeviceVar = groupDeviceVar;
+exports.groupUserVar = groupUserVar;
+const lodash_1 = require("lodash");
+const zod_1 = require("zod");
+const observable_1 = require("../observable");
+const utils_1 = require("../utils");
+const table_1 = require("./orm/table");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
+const rpc_types_1 = require("../rpc-types");
+const schema = zod_1.z.object({
+    persistentVarId: zod_1.z.string(),
+    name: zod_1.z.string(),
+    scope: zod_1.z.enum(['device', 'user', 'group', 'groupDevice', 'groupUser']),
+    value: zod_1.z.object({
+        value: zod_1.z.any(),
+    }).describe('The value of the persistent variable encoded as JSON'),
+    description: zod_1.z.string().optional(),
+    userCreated: zod_1.z.boolean().optional(),
+    isSecret: zod_1.z.boolean().optional(),
+});
+exports.persistentVarsMetaData = {
+    name: 'PersistentVars',
+    description: 'table to persist variables across sessions and devices',
+    primaryKeyName: 'persistentVarId',
+    fields: (0, types_1.schemaToFields)(schema),
+    iconClassName: 'bi bi-braces',
+    indexes: [
+        { fields: ['name'], unique: true },
+    ]
+};
+class PersistentVarsTable extends table_1.Table {
+    async insert(persistentVar) {
+        return this.save(persistentVar);
+    }
+    async update(persistentVar) {
+        return this.save(persistentVar);
+    }
+    async save(persistentVar, opts) {
+        if (!persistentVar.persistentVarId) {
+            persistentVar.persistentVarId = (0, utils_1.newid)();
+        }
+        const dbVar = await this.get(persistentVar.persistentVarId);
+        if (persistentVar.isSecret && persistentVar.value.value !== undefined && !rpc_types_1.isClient) {
+            if (!dbVar || dbVar.value.value !== persistentVar.value.value || dbVar.isSecret !== persistentVar.isSecret) {
+                persistentVar.value.value = await rpc_types_1.rpcServerCalls.encryptData(persistentVar.value.value || '', this.groupId);
+            }
+        }
+        return super.save(persistentVar, opts);
+    }
+    async getPersistentVarValue(name) {
+        const pVars = await this.list({ name });
+        if (pVars.length > 1) {
+            console.warn(`Multiple persistent variables found with name "${name}". Using the last one.`);
+        }
+        const pVar = pVars[pVars.length - 1];
+        return pVar?.value?.value;
+    }
+}
+exports.PersistentVarsTable = PersistentVarsTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(exports.persistentVarsMetaData, schema, PersistentVarsTable);
+function PersistentVars(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(exports.persistentVarsMetaData, schema, PersistentVarsTable);
+}
+async function getPersistentVar(name, dataContext) {
+    const pVars = await PersistentVars(dataContext).list({ name });
+    if (!pVars.length) {
+        return undefined;
+    }
+    const pVarDevice = pVars.find(pVar => pVar.scope === 'device');
+    if (pVarDevice) {
+        return pVarDevice;
+    }
+    return pVars[0];
+}
+/**
+ * A persistent variable that is stored only on this device, in the user's personal db
+ */
+function deviceVar(name, opts) {
+    return pvar(name, { ...opts, scope: 'device' });
+}
+/**
+ * A persistent variable that is stored in the user's personal db and synced across all their devices
+ */
+function userVar(name, opts) {
+    return pvar(name, { ...opts, scope: 'user' });
+}
+/**
+ * A persistent variable that is shared by all users in a group. It is stored in the group's db and synced across all users and devices in the group.
+ * It can have a different value for each group on the device.
+ */
+function groupVar(name, opts) {
+    return pvar(name, { ...opts, scope: 'group' });
+}
+/**
+ * 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.
+ */
+function groupDeviceVar(name, opts) {
+    return pvar(name, { ...opts, scope: 'groupDevice' });
+}
+/**
+ * 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.
+ */
+function groupUserVar(name, opts) {
+    return pvar(name, { ...opts, scope: 'groupUser' });
+}
+function pvar(name, opts) {
+    const currentValue = (0, observable_1.observable)(opts?.dbValue || opts?.defaultValue);
+    const scope = opts.scope || 'device';
+    let isSecret = opts.isSecret;
+    let rec = undefined;
+    currentValue.loadingPromise = new Promise(async (resolve) => {
+        const userContext = opts?.userContext || await (0, user_context_singleton_1.getUserContext)();
+        function getDataContext() {
+            if (opts?.dataContext) {
+                return opts.dataContext;
+            }
+            if (scope === 'group') {
+                return userContext.defaultDataContext();
+            }
+            else {
+                return userContext.userDataContext;
+            }
+        }
+        function getVarNameInDb() {
+            if (scope === 'groupDevice' || scope === 'groupUser') {
+                const dc = opts?.dataContext || userContext.defaultDataContext();
+                // if it's a group var saved in the user's personal db, it's postfixed with the dataContextId to make it unique
+                return name + `_` + dc.dataContextId;
+            }
+            return name;
+        }
+        async function loadRecFromDb() {
+            const dc = getDataContext();
+            const table = PersistentVars(dc);
+            const name = getVarNameInDb();
+            let dbRec = await table.findOne({ 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`);
+                    await table.delete(dbRec);
+                    dbRec = undefined;
+                }
+            }
+            if (!dbRec) {
+                dbRec = {
+                    persistentVarId: (0, utils_1.newid)(),
+                    name,
+                    scope,
+                    isSecret,
+                    value: { value: opts?.defaultValue },
+                };
+            }
+            // if the db says it's secret but the caller didn't specify, assume it's secret
+            if (dbRec.isSecret !== undefined && opts.isSecret === undefined) {
+                isSecret = dbRec.isSecret;
+            }
+            return dbRec;
+        }
+        async function saveVarToDb(value) {
+            if (!rec) {
+                rec = await loadRecFromDb();
+            }
+            const oldValue = rec.value.value;
+            if ((0, lodash_1.isEqual)(value, oldValue)) {
+                return;
+            }
+            rec.value.value = value;
+            const dc = getDataContext();
+            const table = PersistentVars(dc);
+            // delete if value equals default value
+            if (rec.value.value === opts?.defaultValue) {
+                await table.delete(rec);
+                rec.persistentVarId = (0, utils_1.newid)();
+            }
+            else {
+                await table.save(rec);
+            }
+        }
+        // subscribe to db changes
+        userContext.subscribeToDataChangedAcrossAllGroups(PersistentVars(), async (evt) => {
+            const dbRec = evt.data.dataObject;
+            const dbName = getVarNameInDb();
+            if (dbRec.name === dbName && !rec) {
+                rec = await loadRecFromDb();
+            }
+            if (dbRec.persistentVarId === rec?.persistentVarId) {
+                rec = dbRec;
+                if (evt.data.op === 'delete') {
+                    rec.persistentVarId = (0, utils_1.newid)(); // change id so next save creates new pVar
+                    rec.value.value = opts?.defaultValue;
+                }
+                if (!(0, lodash_1.isEqual)(currentValue(), rec.value.value)) {
+                    currentValue(rec.value.value);
+                }
+                return;
+            }
+        });
+        // update group-dependent variables if group context changes and it hasn't been pinned to a specific data context
+        const groupDependentScopes = ['group', 'groupDevice', 'groupUser'];
+        if (!opts?.dataContext && groupDependentScopes.includes(scope)) {
+            userContext.defaultDataContext.subscribe(async (newDataContext) => {
+                rec = await loadRecFromDb();
+                currentValue(rec.value.value);
+            });
+        }
+        if (!Object.keys(opts ?? {}).includes('dbValue')) {
+            rec = await loadRecFromDb();
+            if (!(0, lodash_1.isEqual)(rec.value.value, currentValue())) {
+                currentValue(rec.value.value);
+            }
+        }
+        currentValue.subscribe(newValue => {
+            saveVarToDb(newValue);
+        });
+        resolve(currentValue);
+    });
+    return currentValue;
+}