@peers-app/peers-sdk 0.1.4

package/dist/data/change-tracking.d.ts

@@ -0,0 +1,219 @@
+import { z } from "zod";
+import { ISqlDb, SQLDataSource } from "./orm";
+import { Emitter, Event } from "../events";
+declare const insertChange: z.ZodObject<{
+    changeId: z.ZodEffects<z.ZodString, string, string>;
+    changeType: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"insert">, z.ZodLiteral<"snapshot">]>, z.ZodLiteral<"restore">]>;
+    timestamp: z.ZodNumber;
+    timestampApplied: z.ZodNumber;
+    tableName: z.ZodString;
+    recordId: z.ZodString;
+    newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+}, "strip", z.ZodTypeAny, {
+    changeId: string;
+    changeType: "insert" | "snapshot" | "restore";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord: {} & {
+        [k: string]: any;
+    };
+}, {
+    changeId: string;
+    changeType: "insert" | "snapshot" | "restore";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord: {} & {
+        [k: string]: any;
+    };
+}>;
+export type IChangeInsert = z.infer<typeof insertChange>;
+declare const deleteChange: z.ZodObject<{
+    changeId: z.ZodEffects<z.ZodString, string, string>;
+    changeType: z.ZodLiteral<"delete">;
+    timestamp: z.ZodNumber;
+    timestampApplied: z.ZodNumber;
+    tableName: z.ZodString;
+    recordId: z.ZodString;
+    oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
+}, "strip", z.ZodTypeAny, {
+    changeId: string;
+    changeType: "delete";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+}, {
+    changeId: string;
+    changeType: "delete";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+}>;
+export type IChangeDelete = z.infer<typeof deleteChange>;
+declare const updateChange: z.ZodObject<{
+    changeId: z.ZodEffects<z.ZodString, string, string>;
+    changeType: z.ZodLiteral<"update">;
+    timestamp: z.ZodNumber;
+    timestampApplied: z.ZodNumber;
+    tableName: z.ZodString;
+    recordId: z.ZodString;
+    newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+    jsonDiff: z.ZodArray<z.ZodAny, "many">;
+}, "strip", z.ZodTypeAny, {
+    changeId: string;
+    changeType: "update";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord: {} & {
+        [k: string]: any;
+    };
+    jsonDiff: any[];
+}, {
+    changeId: string;
+    changeType: "update";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord: {} & {
+        [k: string]: any;
+    };
+    jsonDiff: any[];
+}>;
+export type IChangeUpdate = z.infer<typeof updateChange>;
+declare const changeSchema: z.ZodUnion<[z.ZodObject<{
+    changeId: z.ZodEffects<z.ZodString, string, string>;
+    changeType: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"insert">, z.ZodLiteral<"snapshot">]>, z.ZodLiteral<"restore">]>;
+    timestamp: z.ZodNumber;
+    timestampApplied: z.ZodNumber;
+    tableName: z.ZodString;
+    recordId: z.ZodString;
+    newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+}, "strip", z.ZodTypeAny, {
+    changeId: string;
+    changeType: "insert" | "snapshot" | "restore";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord: {} & {
+        [k: string]: any;
+    };
+}, {
+    changeId: string;
+    changeType: "insert" | "snapshot" | "restore";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord: {} & {
+        [k: string]: any;
+    };
+}>, z.ZodObject<{
+    changeId: z.ZodEffects<z.ZodString, string, string>;
+    changeType: z.ZodLiteral<"delete">;
+    timestamp: z.ZodNumber;
+    timestampApplied: z.ZodNumber;
+    tableName: z.ZodString;
+    recordId: z.ZodString;
+    oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
+}, "strip", z.ZodTypeAny, {
+    changeId: string;
+    changeType: "delete";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+}, {
+    changeId: string;
+    changeType: "delete";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+}>, z.ZodObject<{
+    changeId: z.ZodEffects<z.ZodString, string, string>;
+    changeType: z.ZodLiteral<"update">;
+    timestamp: z.ZodNumber;
+    timestampApplied: z.ZodNumber;
+    tableName: z.ZodString;
+    recordId: z.ZodString;
+    newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
+    jsonDiff: z.ZodArray<z.ZodAny, "many">;
+}, "strip", z.ZodTypeAny, {
+    changeId: string;
+    changeType: "update";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord: {} & {
+        [k: string]: any;
+    };
+    jsonDiff: any[];
+}, {
+    changeId: string;
+    changeType: "update";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord: {} & {
+        [k: string]: any;
+    };
+    jsonDiff: any[];
+}>]>;
+export type IChange = z.infer<typeof changeSchema>;
+export declare const changeTrackingSchema: z.ZodObject<{
+    changeId: z.ZodEffects<z.ZodString, string, string>;
+    changeType: z.ZodEnum<["insert", "snapshot", "update", "delete", "restore"]>;
+    timestamp: z.ZodNumber;
+    timestampApplied: z.ZodNumber;
+    tableName: z.ZodString;
+    recordId: z.ZodString;
+    oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
+    newRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
+    jsonDiff: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strip", z.ZodTypeAny, {
+    changeId: string;
+    changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+    oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+    jsonDiff?: any[] | undefined;
+}, {
+    changeId: string;
+    changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
+    timestamp: number;
+    timestampApplied: number;
+    tableName: string;
+    recordId: string;
+    newRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+    oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+    jsonDiff?: any[] | undefined;
+}>;
+export type IChangeAny = z.infer<typeof changeTrackingSchema>;
+export declare class ChangeTrackingTable extends SQLDataSource<IChange> {
+    constructor({ db, }: {
+        db: ISqlDb;
+    });
+    readonly dataChangedEmitter: Emitter<IChange>;
+    readonly dataChanged: Event<IChange>;
+    filterToDeletedIds(recordIds: string[]): Promise<string[]>;
+    filterToMissingIds(recordIds: string[]): Promise<string[]>;
+}
+export {};

package/dist/data/change-tracking.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeTrackingTable = exports.changeTrackingSchema = void 0;
+const zod_1 = require("zod");
+const zod_types_1 = require("../types/zod-types");
+const orm_1 = require("./orm");
+const events_1 = require("../events");
+const utils_1 = require("../utils");
+const changeType = zod_1.z.enum(['insert', 'snapshot', 'update', 'delete', 'restore']);
+const insertChange = zod_1.z.object({
+    changeId: zod_types_1.zodPeerId,
+    changeType: zod_1.z.literal('insert').or(zod_1.z.literal('snapshot')).or(zod_1.z.literal('restore')),
+    timestamp: zod_1.z.number(),
+    timestampApplied: zod_1.z.number(),
+    tableName: zod_1.z.string(),
+    recordId: zod_1.z.string(),
+    newRecord: zod_types_1.zodAnyObject,
+});
+const deleteChange = zod_1.z.object({
+    changeId: zod_types_1.zodPeerId,
+    changeType: zod_1.z.literal('delete'),
+    timestamp: zod_1.z.number(),
+    timestampApplied: zod_1.z.number(),
+    tableName: zod_1.z.string(),
+    recordId: zod_1.z.string(),
+    oldRecord: zod_types_1.zodAnyObject.optional(),
+});
+const updateChange = zod_1.z.object({
+    changeId: zod_types_1.zodPeerId,
+    changeType: zod_1.z.literal('update'),
+    timestamp: zod_1.z.number(),
+    timestampApplied: zod_1.z.number(),
+    tableName: zod_1.z.string(),
+    recordId: zod_1.z.string(),
+    newRecord: zod_types_1.zodAnyObject,
+    jsonDiff: zod_1.z.array(zod_1.z.any()),
+});
+const changeSchema = zod_1.z.union([insertChange, deleteChange, updateChange]);
+exports.changeTrackingSchema = zod_1.z.object({
+    changeId: zod_types_1.zodPeerId,
+    changeType: changeType,
+    timestamp: zod_1.z.number(),
+    timestampApplied: zod_1.z.number(),
+    tableName: zod_1.z.string(),
+    recordId: zod_1.z.string(),
+    oldRecord: zod_types_1.zodAnyObject.optional(),
+    newRecord: zod_types_1.zodAnyObject.optional(),
+    jsonDiff: zod_1.z.array(zod_1.z.any()).optional(),
+});
+const changeTrackingTableMetaData = {
+    name: 'ChangeTracking',
+    primaryKeyName: 'changeId',
+    description: 'Change tracking table',
+    fields: (0, orm_1.schemaToFields)(exports.changeTrackingSchema),
+    indexes: [
+        { fields: ['tableName'] },
+        { fields: ['recordId'] },
+        { fields: ['changeType'] },
+        { fields: ['timestamp'] },
+        { fields: ['timestampApplied'] },
+    ],
+    localOnly: true,
+};
+class ChangeTrackingTable extends orm_1.SQLDataSource {
+    constructor({ db, }) {
+        super(db, changeTrackingTableMetaData, changeSchema);
+        const tableName = changeTrackingTableMetaData.name;
+        this.dataChangedEmitter = new events_1.Emitter(tableName + "_DataChanged_" + (0, utils_1.newid)());
+        // @ts-ignore
+        this.dataChanged = this.dataChangedEmitter.event;
+        // TODO turn this back on to observe changes and make it performant
+        // this.dataChanged.subscribe((change) => {
+        //   console.log("Data changed:", change);
+        // });
+    }
+    dataChangedEmitter;
+    dataChanged;
+    async filterToDeletedIds(recordIds) {
+        await this.initTable();
+        // find all changes who have been deleted
+        const deletedRecordsResult = await this.db.all(`
+      WITH InsertsAndDeletes AS (
+        SELECT 
+          recordId,
+          MAX(timestamp) as last_timestamp
+        FROM "${this.tableName}"
+        WHERE
+          recordId IN (${recordIds.map(() => '?').join(',')}) AND
+          changeType IN ('restore', 'delete')
+        GROUP BY recordId
+      )
+      SELECT 
+        ct.recordId 
+      FROM "${this.tableName}" ct
+      JOIN InsertsAndDeletes iad ON ct.recordId = iad.recordId AND ct.timestamp = iad.last_timestamp
+      WHERE
+        ct.changeType = 'delete'
+      `, recordIds);
+        return deletedRecordsResult.map(d => d.recordId);
+    }
+    async filterToMissingIds(recordIds) {
+        await this.initTable();
+        const missingRecordsResult = await this.db.all(`
+      WITH InputRecordIds(recordId) AS (
+        VALUES
+          ${recordIds.map(() => '(?)').join(',\n      ')}
+      )
+      SELECT 
+        i.recordId
+      FROM InputRecordIds AS i
+      LEFT JOIN "${this.tableName}" AS existing
+        ON i.recordId = existing.recordId
+      WHERE existing.recordId IS NULL;
+      `, recordIds);
+        let missingIds = missingRecordsResult.map(d => d.recordId);
+        return missingIds;
+    }
+}
+exports.ChangeTrackingTable = ChangeTrackingTable;

package/dist/data/channels.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
+export declare const channelSchema: z.ZodObject<{
+    channelId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    createdAt: z.ZodDate;
+    owningGroupId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    createdAt: Date;
+    channelId: string;
+    owningGroupId: string;
+}, {
+    name: string;
+    description: string;
+    createdAt: Date;
+    channelId: string;
+    owningGroupId: string;
+}>;
+export type IChannel = z.infer<typeof channelSchema>;
+export declare function Channels(dataContext?: DataContext): import("./orm").Table<{
+    name: string;
+    description: string;
+    createdAt: Date;
+    channelId: string;
+    owningGroupId: string;
+}>;

package/dist/data/channels.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelSchema = void 0;
+exports.Channels = Channels;
+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.channelSchema = zod_1.z.object({
+    channelId: zod_1.z.string(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    createdAt: zod_1.z.date(),
+    owningGroupId: zod_1.z.string(),
+});
+const metaData = {
+    name: 'Channels',
+    description: 'Different channels of communication for peers and assistants',
+    primaryKeyName: 'channelId',
+    fields: (0, types_1.schemaToFields)(exports.channelSchema),
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.channelSchema);
+function Channels(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.channelSchema);
+}

package/dist/data/data-locks.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { IPeerDevice } from "../types/peer-device";
+import { ITableMetaData, Table, ITableDependencies } from "./orm";
+export declare const dataLockSchema: z.ZodObject<{
+    dataLockId: z.ZodEffects<z.ZodString, string, string>;
+    recordId: z.ZodString;
+    lockedUntil: z.ZodNumber;
+    acknowledged: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    recordId: string;
+    dataLockId: string;
+    lockedUntil: number;
+    acknowledged?: number | undefined;
+}, {
+    recordId: string;
+    dataLockId: string;
+    lockedUntil: number;
+    acknowledged?: number | undefined;
+}>;
+export type IDataLock = z.infer<typeof dataLockSchema>;
+export declare class DataLocksTable extends Table<IDataLock> {
+    readonly DEFAULT_LOCK_TIME_MS = 300000;
+    readonly DEFAULT_TIMEOUT_MS = 20000;
+    readonly DEAD_PERIOD_MS = 10000;
+    peerDevice: IPeerDevice | undefined;
+    constructor(metaData: ITableMetaData, deps: ITableDependencies);
+    getCurrentLock(recordId: string): Promise<IDataLock | undefined>;
+    releaseLock(dataLock: IDataLock): Promise<void>;
+    createLock(recordId: string, lockTimeMs?: number): Promise<IDataLock>;
+    acquireLock(lock: IDataLock, timeoutMs?: number): Promise<IDataLock | undefined>;
+    acquireLock(recordId: string, timeoutMs?: number, lockTimeMs?: number): Promise<IDataLock | undefined>;
+    renewLock(dataLock: IDataLock, lockTimeMs?: number): Promise<IDataLock | undefined>;
+    private countLockAcknowledgements;
+    private lockStatus;
+    private waitForLockConfirmedAndCurrent;
+}
+export declare function DataLocks(dataContext?: any): DataLocksTable;

package/dist/data/data-locks.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataLocksTable = exports.dataLockSchema = void 0;
+exports.DataLocks = DataLocks;
+const lodash_1 = require("lodash");
+const zod_1 = require("zod");
+const zod_types_1 = require("../types/zod-types");
+const utils_1 = require("../utils");
+const orm_1 = require("./orm");
+const context_1 = require("../context");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+/*
+  This works by waiting for a majority of peers to acknowledge the lock.
+  Once that happens it is considered "well propagated" and it also assumes older
+  locks from other devices have all been synced but that's not actually guaranteed.
+  
+  This system works okay for a few peers but it won't scale well when _all_ the peers are trying to
+  do something like emit a scheduled event at the same time.  They'll all try to acquire the lock at the same time
+  and even if this works, it'll create a ton of traffic and contention on the locks table.
+  
+  The issue with emitting scheduled events might be an edge case but it still feels like the locking problem
+  should be solved in a more robust and scalable way.
+  
+  We already have an election system for preferred connections.  This feels like it could be solved in a similar way,
+  maybe by just using the existing elections.  I also suspect there are going to be other problems that would
+  benefit greatly from utilizing an elected coordinator for these kinds of problems that require coordination
+    
+*/
+exports.dataLockSchema = zod_1.z.object({
+    dataLockId: zod_types_1.zodPeerId,
+    recordId: zod_1.z.string(),
+    lockedUntil: zod_1.z.number(),
+    acknowledged: zod_1.z.number().optional(), // timestamp of acknowledgment
+});
+const dataLocksTableMetaData = {
+    name: 'DataLocks',
+    primaryKeyName: 'dataLockId',
+    description: 'Data locks table to track exclusive write access to records in other tables.',
+    fields: (0, orm_1.schemaToFields)(exports.dataLockSchema),
+    indexes: [
+        { fields: ['recordId'] },
+    ],
+};
+class DataLocksTable extends orm_1.Table {
+    DEFAULT_LOCK_TIME_MS = 300_000; // 5 minutes
+    DEFAULT_TIMEOUT_MS = 20_000; // 20 seconds
+    DEAD_PERIOD_MS = 10_000; // The cannot be renewed in it's last 10 seconds to avoid races
+    peerDevice;
+    constructor(metaData, deps) {
+        super(metaData, deps);
+        // signal to other peers when we become aware of a new data lock
+        this.dataChanged.subscribe(async (evt) => {
+            const dataLock = evt.dataObject;
+            if (evt.op === 'insert') {
+                dataLock.acknowledged = (0, utils_1.getTimestamp)();
+                this.dataSource.update(dataLock);
+            }
+        });
+    }
+    async getCurrentLock(recordId) {
+        const locks = await this.list({
+            recordId,
+            lockedUntil: { $gt: Date.now() }, // Only consider locks that are still valid
+        });
+        return (0, lodash_1.sortBy)(locks, 'dataLockId')[0];
+    }
+    async releaseLock(dataLock) {
+        // Remove the lock from the database
+        await this.delete(dataLock);
+    }
+    async createLock(recordId, lockTimeMs = this.DEFAULT_LOCK_TIME_MS) {
+        const newLock = {
+            dataLockId: (0, utils_1.newid)(),
+            recordId,
+            lockedUntil: Date.now() + lockTimeMs,
+        };
+        return await this.insert(newLock);
+    }
+    async acquireLock(recordIdOrLock, timeoutMs = this.DEFAULT_TIMEOUT_MS, lockTimeMs = this.DEFAULT_LOCK_TIME_MS) {
+        const lock = typeof recordIdOrLock === 'string'
+            ? await this.createLock(recordIdOrLock, lockTimeMs)
+            : recordIdOrLock;
+        const recordId = lock.recordId;
+        const confirmedLock = await this.waitForLockConfirmedAndCurrent(lock, timeoutMs);
+        if (confirmedLock) {
+            await this.renewLock(confirmedLock, lockTimeMs);
+            const currentLock = await this.getCurrentLock(recordId);
+            if (!currentLock || currentLock.dataLockId !== confirmedLock.dataLockId) {
+                console.warn(`Lock acquisition failed for ${recordId}`);
+                await this.releaseLock(confirmedLock); // clean up unconfirmed lock
+                return undefined; // Return undefined if the lock could not be renewed
+            }
+            return currentLock;
+        }
+        else {
+            await this.releaseLock(lock); // clean up unconfirmed lock
+            return undefined; // Return undefined if the lock could not be acquired
+        }
+    }
+    async renewLock(dataLock, lockTimeMs = this.DEFAULT_LOCK_TIME_MS) {
+        if (dataLock.lockedUntil < Date.now() - this.DEAD_PERIOD_MS) {
+            console.warn(`Lock renewal rejected for expired lock ${dataLock.dataLockId} for ${dataLock.recordId}`);
+            return undefined;
+        }
+        dataLock.lockedUntil = Date.now() + lockTimeMs;
+        const renewedLock = await this.update(dataLock);
+        let currentLock = await this.getCurrentLock(dataLock.recordId);
+        if (!currentLock || currentLock.dataLockId !== dataLock.dataLockId) {
+            // currently we don't allow renewing a lock if it is not the current lock - this could change in the future if needed
+            console.warn(`Lock renewal failed for ${dataLock.dataLockId} on ${dataLock.recordId}`);
+            return undefined;
+        }
+        return renewedLock;
+    }
+    async countLockAcknowledgements(lock) {
+        if (!this.peerDevice)
+            throw new Error(`Peer device not set for DataLocksTable`);
+        const updates = await this.peerDevice.listChanges({
+            tableName: dataLocksTableMetaData.name,
+            recordId: lock.dataLockId,
+            changeType: 'update',
+        });
+        const acknowledgedUpdates = updates.map(u => u.newRecord.acknowledged).filter(a => a !== undefined);
+        // NOTE this could potentially miscount if two peers acknowledge the lock with the same timestamp (very unlikely)
+        return (0, lodash_1.uniq)(acknowledgedUpdates).length;
+    }
+    async lockStatus(lock) {
+        if (!this.peerDevice)
+            throw new Error(`Peer device not set for DataLocksTable`);
+        const connectionCount = (await this.peerDevice.getNetworkInfo()).connections.length;
+        const ackCnt = await this.countLockAcknowledgements(lock);
+        const acksNeeded = Math.ceil((connectionCount * 0.7) + 1); // 70% of the connections and +1 for the local device
+        if (ackCnt >= acksNeeded) {
+            return 'confirmed';
+        }
+        return 'pending';
+    }
+    async waitForLockConfirmedAndCurrent(lock, timeoutMs = this.DEFAULT_TIMEOUT_MS) {
+        const startTime = Date.now();
+        let resolveLock;
+        const confirmPromise = new Promise(async (resolve) => {
+            resolveLock = resolve;
+        });
+        const subscription = this.dataChanged.subscribe(async (evt) => {
+            if (evt.dataObject.recordId === lock.recordId) {
+                checkLockStatus();
+            }
+        });
+        const checkLockStatus = async () => {
+            const status = await this.lockStatus(lock);
+            if (status === 'confirmed') {
+                const currentLock = await this.getCurrentLock(lock.recordId);
+                if (currentLock?.dataLockId === lock.dataLockId) {
+                    subscription.unsubscribe();
+                    clearTimeout(timeoutId);
+                    resolveLock(lock);
+                    return;
+                }
+                console.debug(`Lock confirmed but not current for ${lock.recordId}`);
+            }
+            if (Date.now() - startTime > timeoutMs) {
+                console.warn(`Lock confirmation timed out for ${lock.recordId}`);
+                subscription.unsubscribe();
+                clearTimeout(timeoutId);
+                resolveLock(undefined);
+            }
+        };
+        const timeoutId = setTimeout(() => {
+            checkLockStatus(); // Check lock status after timeout
+        }, timeoutMs + 1);
+        checkLockStatus(); // Initial check for lock status
+        return confirmPromise;
+    }
+}
+exports.DataLocksTable = DataLocksTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(dataLocksTableMetaData, exports.dataLockSchema, DataLocksTable);
+function DataLocks(dataContext) {
+    const tableFactory = (0, context_1.getTableContainer)(dataContext);
+    return tableFactory.getTable(dataLocksTableMetaData);
+}

package/dist/data/data-locks.test.d.ts

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