@peers-app/peers-sdk 0.15.5 → 0.16.1

package/dist/data/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./assistants";
 export * from "./change-tracking";
 export * from "./channels";
-export * from "./data-locks";
 export * from "./device-sync-info";
 export * from "./devices";
 export * from "./embeddings";

package/dist/data/index.js

@@ -17,7 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./assistants"), exports);
 __exportStar(require("./change-tracking"), exports);
 __exportStar(require("./channels"), exports);
-__exportStar(require("./data-locks"), exports);
 __exportStar(require("./device-sync-info"), exports);
 __exportStar(require("./devices"), exports);
 __exportStar(require("./embeddings"), exports);

package/dist/data/orm/table-container.d.ts

@@ -1,4 +1,5 @@
 import type { z } from "zod";
+import type { ITableDefinitionRecord } from "../table-definitions-table";
 import { Table } from "./table";
 import type { ITableDefinition, TableConstructor, TableFactory } from "./table-definitions.type";
 import { type ITableMetaData } from "./types";
@@ -52,6 +53,27 @@ export declare class TableContainer {
      * Returns the table instance if found, or null if no definition exists.
      */
     getFallbackTable(tableName: string): Promise<Table<any> | null>;
+    /**
+     * Return the names of all tables whose TableDefinitions record has `deleted` set.
+     * Used by sync to exclude change records for deleted tables.
+     *
+     * @returns Array of table names (as stored in the `name` column of TableDefinitions).
+     */
+    getDeletedTableNames(): Promise<string[]>;
+    /**
+     * Return all TableDefinitions records that have been marked as deleted.
+     * Used by the Data Explorer UI to display deleted tables.
+     *
+     * @returns Full {@link ITableDefinitionRecord} objects with populated `deleted` timestamps.
+     */
+    getDeletedTableDefinitions(): Promise<ITableDefinitionRecord[]>;
+    /**
+     * Return the names of all tables whose metadata marks them as local-only.
+     * Used by sync to exclude local-only change records from remote exchange.
+     *
+     * @returns Array of full table names for local-only table definitions.
+     */
+    getLocalOnlyTableNames(): string[];
     /**
      * Register a table definition from a synced TableDefinitions record.
      * These go into the fallback tier (no custom constructor) so they never

package/dist/data/orm/table-container.js

@@ -158,6 +158,15 @@ class TableContainer {
                 .get(metaData.tableId)
                 .then((existing) => {
                 if (existing) {
+                    // Code-registration is authoritative: if the table was marked deleted,
+                    // clear the flag and force an update so sync propagates the revival.
+                    if (existing.deleted) {
+                        record.deleted = undefined;
+                        return tableDefsTable.save(record, {
+                            restoreIfDeleted: true,
+                            saveAsSnapshot: true,
+                        });
+                    }
                     const result = checkVersionedUpdate(existing.versionNumber, record.versionNumber, existing.metaData, record.metaData);
                     if (result === "skip") {
                         return;
@@ -225,7 +234,7 @@ class TableContainer {
         if (!this.fallbackSubscribed) {
             this.fallbackSubscribed = true;
             tableDefsTable.dataChanged.subscribe((event) => {
-                if (event.op === "delete") {
+                if (event.op === "delete" || event.dataObject?.deleted) {
                     const md = event.dataObject?.metaData;
                     if (md) {
                         const name = (0, utils_1.getFullTableName)(md);
@@ -239,12 +248,63 @@ class TableContainer {
         }
         // Query for this specific table definition
         const record = await tableDefsTable.findOne({ name: tableName });
-        if (!record)
+        if (!record || record.deleted)
             return null;
         this.registerFromTableDefinitionRecord(record);
         // Now instantiate via getTableByName which checks fallbackDefinitions
         return this.getTableByName(tableName);
     }
+    /**
+     * Return the names of all tables whose TableDefinitions record has `deleted` set.
+     * Used by sync to exclude change records for deleted tables.
+     *
+     * @returns Array of table names (as stored in the `name` column of TableDefinitions).
+     */
+    async getDeletedTableNames() {
+        const tableDefsTable = this.tableInstances.TableDefinitions;
+        if (!tableDefsTable)
+            return [];
+        const deletedRecords = await tableDefsTable.list({
+            deleted: { $exists: true },
+        });
+        return deletedRecords.map((r) => r.name);
+    }
+    /**
+     * Return all TableDefinitions records that have been marked as deleted.
+     * Used by the Data Explorer UI to display deleted tables.
+     *
+     * @returns Full {@link ITableDefinitionRecord} objects with populated `deleted` timestamps.
+     */
+    async getDeletedTableDefinitions() {
+        const tableDefsTable = this.tableInstances.TableDefinitions;
+        if (!tableDefsTable)
+            return [];
+        return tableDefsTable.list({ deleted: { $exists: true } });
+    }
+    /**
+     * Return the names of all tables whose metadata marks them as local-only.
+     * Used by sync to exclude local-only change records from remote exchange.
+     *
+     * @returns Array of full table names for local-only table definitions.
+     */
+    getLocalOnlyTableNames() {
+        const names = [];
+        const fullDefinitions = [
+            ...Object.values(table_definitions_system_1.systemTableDefinitions),
+            ...Object.values(this.tableDefinitions),
+        ];
+        for (const tableDefinition of fullDefinitions) {
+            if (tableDefinition.metaData.localOnly) {
+                names.push((0, utils_1.getFullTableName)(tableDefinition.metaData));
+            }
+        }
+        for (const [tableName, fallbackDefinition] of Object.entries(this.fallbackDefinitions)) {
+            if (fallbackDefinition.metaData.localOnly && !names.includes(tableName)) {
+                names.push(tableName);
+            }
+        }
+        return names;
+    }
     /**
      * Register a table definition from a synced TableDefinitions record.
      * These go into the fallback tier (no custom constructor) so they never
@@ -260,6 +320,12 @@ class TableContainer {
             return;
         }
         const tableName = (0, utils_1.getFullTableName)(metaData);
+        // Deleted tables should not be registered as fallbacks
+        if (record.deleted) {
+            delete this.fallbackDefinitions[tableName];
+            delete this.fallbackInstances[tableName];
+            return;
+        }
         // Don't overwrite a full (code-registered) definition -- that always takes precedence
         const fullDef = this.tableDefinitions[tableName] || table_definitions_system_1.systemTableDefinitions[tableName];
         if (fullDef) {

package/dist/data/orm/table-container.test.js

@@ -67,7 +67,7 @@ function createTestHarness() {
         .fn()
         .mockImplementation((metaData, schema, TableClass) => {
         const deps = {
-            dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, "test-context"),
+            dataSource: new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema ?? zod_1.z.object({}), "test-context"),
             eventRegistry,
         };
         return new (TableClass || table_1.Table)(metaData, deps);
@@ -134,7 +134,7 @@ describe("Tiered table instances", () => {
         expect(table).not.toBeInstanceOf(CustomTestTable);
     });
     it("getAllTables should prefer full instances over fallback instances", () => {
-        const { container, testMetaData, testSchema, defRecord, tableFactory } = createTestHarness();
+        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
         // Create a second table that will only have a fallback definition
         const tableId2 = (0, utils_1.newid)();
         const metaData2 = {
@@ -172,3 +172,58 @@ describe("Tiered table instances", () => {
         expect(secondTable).not.toBeInstanceOf(CustomTestTable);
     });
 });
+describe("getLocalOnlyTableNames", () => {
+    it("returns localOnly code-registered table names and excludes non-local tables", () => {
+        const { container, testSchema } = createTestHarness();
+        const localOnlyMetaData = {
+            tableId: (0, utils_1.newid)(),
+            name: "LocalOnlyTable",
+            description: "A local-only table",
+            primaryKeyName: "id",
+            fields: [
+                { name: "id", type: field_type_1.FieldType.id },
+                { name: "title", type: field_type_1.FieldType.string },
+            ],
+            localOnly: true,
+        };
+        const syncedMetaData = {
+            tableId: (0, utils_1.newid)(),
+            name: "SyncedTable",
+            description: "A synced table",
+            primaryKeyName: "id",
+            fields: [
+                { name: "id", type: field_type_1.FieldType.id },
+                { name: "title", type: field_type_1.FieldType.string },
+            ],
+        };
+        container.registerTableDefinition({
+            metaData: localOnlyMetaData,
+            schema: testSchema,
+        });
+        container.registerTableDefinition({
+            metaData: syncedMetaData,
+            schema: testSchema,
+        });
+        const localOnlyNames = container.getLocalOnlyTableNames();
+        expect(localOnlyNames).toContain((0, utils_1.getFullTableName)(localOnlyMetaData));
+        expect(localOnlyNames).not.toContain((0, utils_1.getFullTableName)(syncedMetaData));
+    });
+    it("returns localOnly fallback table names without duplicates", () => {
+        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
+        const localOnlyMetaData = {
+            ...testMetaData,
+            localOnly: true,
+        };
+        const localOnlyDefRecord = {
+            ...defRecord,
+            metaData: localOnlyMetaData,
+        };
+        container.registerFromTableDefinitionRecord(localOnlyDefRecord);
+        container.registerTableDefinition({
+            metaData: localOnlyMetaData,
+            schema: testSchema,
+        });
+        const localOnlyNames = container.getLocalOnlyTableNames();
+        expect(localOnlyNames.filter((name) => name === defRecord.name)).toHaveLength(1);
+    });
+});

package/dist/data/table-definitions-table.d.ts

@@ -1,10 +1,12 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
+/** Zod schema for rows in the {@link TableDefinitions} system table. */
 export declare const tableDefinitionRecordSchema: z.ZodObject<{
     tableId: z.ZodString;
     name: z.ZodString;
     metaData: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
     versionNumber: z.ZodDefault<z.ZodNumber>;
+    deleted: z.ZodOptional<z.ZodDate>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     metaData: {} & {
@@ -12,15 +14,26 @@ export declare const tableDefinitionRecordSchema: z.ZodObject<{
     };
     tableId: string;
     versionNumber: number;
+    deleted?: Date | undefined;
 }, {
     name: string;
     metaData: {} & {
         [k: string]: any;
     };
     tableId: string;
+    deleted?: Date | undefined;
     versionNumber?: number | undefined;
 }>;
+/** A single row in the {@link TableDefinitions} system table. */
 export type ITableDefinitionRecord = z.infer<typeof tableDefinitionRecordSchema>;
+/**
+ * Accessor for the TableDefinitions system table.
+ *
+ * This table stores table schemas as tracked, synced data so that peers can
+ * learn about table definitions without needing the originating package installed.
+ *
+ * @param dataContext - Optional data context; when omitted the singleton context is used.
+ */
 export declare function TableDefinitions(dataContext?: DataContext): import("./orm").Table<{
     name: string;
     metaData: {} & {
@@ -28,4 +41,5 @@ export declare function TableDefinitions(dataContext?: DataContext): import("./o
     };
     tableId: string;
     versionNumber: number;
+    deleted?: Date | undefined;
 }>;

package/dist/data/table-definitions-table.js

@@ -7,6 +7,7 @@ const user_context_singleton_1 = require("../context/user-context-singleton");
 const zod_types_1 = require("../types/zod-types");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
+/** Zod schema for rows in the {@link TableDefinitions} system table. */
 exports.tableDefinitionRecordSchema = zod_1.z.object({
     tableId: zod_1.z.string().describe("Primary key - same as ITableMetaData.tableId"),
     name: zod_1.z.string().describe("Table name"),
@@ -15,6 +16,10 @@ exports.tableDefinitionRecordSchema = zod_1.z.object({
         .number()
         .default(0)
         .describe("Version number set by the developer in the table definition; higher value wins during sync"),
+    deleted: zod_1.z
+        .date()
+        .optional()
+        .describe("When set, the table was deleted at this time. Changes for this table should be ignored during sync."),
 });
 const metaData = {
     name: "TableDefinitions",
@@ -24,6 +29,14 @@ const metaData = {
     indexes: [{ fields: ["name"] }],
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.tableDefinitionRecordSchema);
+/**
+ * Accessor for the TableDefinitions system table.
+ *
+ * This table stores table schemas as tracked, synced data so that peers can
+ * learn about table definitions without needing the originating package installed.
+ *
+ * @param dataContext - Optional data context; when omitted the singleton context is used.
+ */
 function TableDefinitions(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.tableDefinitionRecordSchema);
 }

package/dist/data/workflow-logs.js

@@ -36,6 +36,7 @@ const metaData = {
     description: "The log entries for workflow runs.",
     primaryKeyName: "workflowLogId",
     fields: (0, types_1.schemaToFields)(exports.workflowLogSchema),
+    localOnly: true,
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.workflowLogSchema);
 function WorkflowLogs(dataContext) {

package/dist/data/workflow-runs.d.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
-import { type IDataLock } from "./data-locks";
 import { Table } from "./orm/table";
 export declare const workflowRunSchema: z.ZodObject<{
     workflowRunId: z.ZodEffects<z.ZodString, string, string>;
@@ -77,19 +76,9 @@ export declare const workflowRunSchema: z.ZodObject<{
 }>;
 export type IWorkflowRun = z.infer<typeof workflowRunSchema>;
 declare class WorkflowRunTable extends Table<IWorkflowRun> {
-    /** @deprecated Direct calls to save forbidden; use insert or saveWithLock */
-    save(..._args: Parameters<Table<any>["insert"]>): never;
-    /** @deprecated Direct calls to update forbidden; use saveWithLock() */
-    update(..._args: Parameters<Table<any>["update"]>): never;
-    saveWithLock(workflowRun: IWorkflowRun, lock?: IDataLock): Promise<IWorkflowRun>;
-    acquireLock(workflowRunId: string, timeoutMs?: number, lockTimeMs?: number): Promise<IDataLock | undefined>;
-    saveAndRelease(workflowRun: IWorkflowRun, lock: IDataLock): Promise<void>;
     haltRun(workflowRunId: string): Promise<void>;
-    /**
-     * Removes the error state from a workflow run and locks it so
-     * additional editing can be done before it is re-run.
-     */
-    clearErrorState(workflowRunId: string): Promise<IDataLock | false>;
+    /** Removes the error state from a workflow run so it can be re-run. */
+    clearErrorState(workflowRunId: string): Promise<boolean>;
 }
 export declare function WorkflowRuns(dataContext?: DataContext): WorkflowRunTable;
 export interface IRunWorkflowOptions {

package/dist/data/workflow-runs.js

@@ -47,7 +47,6 @@ const zod_types_1 = require("../types/zod-types");
 const utils_1 = require("../utils");
 const assistants_1 = require("./assistants");
 const channels_1 = require("./channels");
-const data_locks_1 = require("./data-locks");
 const groups_1 = require("./groups");
 const messages_1 = require("./messages");
 const orm_1 = require("./orm");
@@ -104,6 +103,7 @@ const metaData = {
     description: "workflows instances that have been run manually, from messages, or from events",
     primaryKeyName: "workflowRunId",
     fields: (0, types_1.schemaToFields)(exports.workflowRunSchema),
+    localOnly: true,
     indexes: [
         { fields: ["workflowId"] },
         { fields: ["parentMessageId"] },
@@ -123,83 +123,6 @@ let WorkflowRunTable = (() => {
             __esDecorate(this, null, _haltRun_decorators, { kind: "method", name: "haltRun", static: false, private: false, access: { has: obj => "haltRun" in obj, get: obj => obj.haltRun }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        /** @deprecated Direct calls to save forbidden; use insert or saveWithLock */
-        save(..._args) {
-            throw new Error("Direct inserts forbidden; use insert() or saveWithLock()");
-        }
-        /** @deprecated Direct calls to update forbidden; use saveWithLock() */
-        update(..._args) {
-            throw new Error("Direct updates forbidden; use saveWithLock()");
-        }
-        async saveWithLock(workflowRun, lock) {
-            if (!workflowRun.workflowRunId) {
-                workflowRun.workflowRunId = (0, utils_1.newid)();
-                return super.insert(workflowRun);
-            }
-            let lockedForThisSave = false;
-            if (!lock) {
-                lock = await (0, data_locks_1.DataLocks)().acquireLock(workflowRun.workflowRunId);
-                lockedForThisSave = true;
-            }
-            else {
-                const currentLock = await (0, data_locks_1.DataLocks)().getCurrentLock(workflowRun.workflowRunId);
-                if (currentLock?.dataLockId !== lock.dataLockId) {
-                    throw new Error(`Provided lock is not the current lock for workflowRunId ${workflowRun.workflowRunId} - aborting save`);
-                }
-            }
-            if (!lock) {
-                throw new Error(`Could not acquire lock for workflow run ${workflowRun.workflowRunId}`);
-            }
-            if (lock.recordId !== workflowRun.workflowRunId) {
-                throw new Error(`Provided lock recordId ${lock?.recordId} does not match workflowRunId ${workflowRun.workflowRunId}`);
-            }
-            let dbData = await this.get(workflowRun.workflowRunId);
-            if (dbData && !lock) {
-                const currentLock = await (0, data_locks_1.DataLocks)().getCurrentLock(workflowRun.workflowRunId);
-                if (currentLock) {
-                    throw new Error(`Workflow run ${workflowRun.workflowRunId} is locked by ${currentLock.dataLockId} - the lock will timeout at ${new Date(currentLock.lockedUntil)}`);
-                }
-            }
-            if (dbData?.inErrorState) {
-                throw new Error(`Workflow run ${workflowRun.workflowRunId} is in an error state - use clearErrorState to continue the run`);
-            }
-            if (dbData) {
-                dbData = await super.update(workflowRun);
-            }
-            else {
-                dbData = await super.insert(workflowRun);
-            }
-            if (lockedForThisSave) {
-                await (0, data_locks_1.DataLocks)().releaseLock(lock);
-            }
-            return dbData;
-        }
-        async acquireLock(workflowRunId, timeoutMs, lockTimeMs) {
-            const workflowDbData = await this.get(workflowRunId);
-            if (!workflowDbData)
-                return undefined;
-            if (workflowDbData.inErrorState) {
-                console.warn(`Workflow run ${workflowRunId} is in an error state - not acquiring lock`);
-                return undefined;
-            }
-            return await (0, data_locks_1.DataLocks)().acquireLock(workflowRunId, timeoutMs, lockTimeMs);
-        }
-        async saveAndRelease(workflowRun, lock) {
-            const workflowDbData = await this.get(workflowRun.workflowRunId);
-            if (!workflowDbData)
-                return;
-            const currentLock = await (0, data_locks_1.DataLocks)().getCurrentLock(workflowRun.workflowRunId);
-            if (!currentLock || currentLock.dataLockId !== lock.dataLockId) {
-                console.warn(`Workflow run ${workflowRun.workflowRunId} is not locked by ${lock.dataLockId} - aborting save`);
-                return;
-            }
-            if (workflowDbData.inErrorState) {
-                console.warn(`Workflow run ${workflowRun.workflowRunId} is in an error state - aborting save`);
-                return;
-            }
-            await super.update(workflowRun);
-            await (0, data_locks_1.DataLocks)().releaseLock(lock);
-        }
         async haltRun(workflowRunId) {
             const run = await super.get(workflowRunId);
             if (!run) {
@@ -212,16 +135,6 @@ let WorkflowRunTable = (() => {
             if (!run.completedAt) {
                 run.inErrorState = true;
                 await super.update(run);
-                // Release any existing lock
-                while (true) {
-                    const currentLock = await (0, data_locks_1.DataLocks)().getCurrentLock(workflowRunId);
-                    if (currentLock) {
-                        await (0, data_locks_1.DataLocks)().releaseLock(currentLock);
-                    }
-                    else {
-                        break; // No lock to release
-                    }
-                }
                 // also halt any child runs
                 this.list({ parentWorkflowRunId: workflowRunId })
                     .then(async (childRuns) => {
@@ -241,10 +154,7 @@ let WorkflowRunTable = (() => {
                 logger(runHaltMessage);
             }
         }
-        /**
-         * Removes the error state from a workflow run and locks it so
-         * additional editing can be done before it is re-run.
-         */
+        /** Removes the error state from a workflow run so it can be re-run. */
         async clearErrorState(workflowRunId) {
             const run = await super.get(workflowRunId);
             if (!run) {
@@ -254,14 +164,9 @@ let WorkflowRunTable = (() => {
                 console.warn(`Workflow run ${workflowRunId} is not in an error state - not clearing`);
                 return false;
             }
-            const lock = await (0, data_locks_1.DataLocks)().acquireLock(workflowRunId);
-            if (!lock) {
-                console.warn(`Could not acquire lock for workflow run ${workflowRunId}`);
-                return false;
-            }
             run.inErrorState = false;
             await super.update(run);
-            return lock;
+            return true;
         }
         constructor() {
             super(...arguments);

package/dist/data/workflows.js

@@ -11,6 +11,7 @@ const metaData = {
     primaryKeyName: "workflowId",
     fields: (0, types_1.schemaToFields)(workflow_1.workflowSchema),
     iconClassName: "bi bi-database-fill-gear",
+    localOnly: true,
     indexes: [{ fields: ["name"] }],
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, workflow_1.workflowSchema);

package/dist/rpc-types.d.ts

@@ -62,6 +62,7 @@ export declare const rpcServerCalls: {
     resetChangeTracking: () => Promise<void>;
     deleteLocalDatabase: () => Promise<void>;
     importGroupShare: (groupShareJson: string) => Promise<string>;
+    registerWithPeersServices: () => Promise<string>;
     appQuit: () => Promise<void>;
     appRestart: () => Promise<void>;
     dbQuery: (query: string, dataContextId?: string) => Promise<{

package/dist/rpc-types.js

@@ -35,6 +35,7 @@ exports.rpcServerCalls = {
     resetChangeTracking: rpcStub("resetChangeTracking"),
     deleteLocalDatabase: rpcStub("deleteLocalDatabase"),
     importGroupShare: rpcStub("importGroupShare"),
+    registerWithPeersServices: rpcStub("registerWithPeersServices"),
     // App lifecycle commands (for CLI control)
     appQuit: rpcStub("appQuit"),
     appRestart: rpcStub("appRestart"),

package/dist/types/workflow-run-context.d.ts

@@ -2,8 +2,10 @@ import type { IToolInstance } from "../data/tools";
 import type { IWorkflowRun } from "../data/workflow-runs";
 import type { IAssistantRunnerArgs } from "./assistant-runner-args";
 import type { IWorkflowLogger } from "./workflow-logger";
+/** Runtime context passed to tools while processing a workflow run instruction. */
 export interface IWorkflowRunContext {
     contextId: string;
+    dataContextId: string;
     workflowRun: IWorkflowRun;
     logger: IWorkflowLogger;
     getAssistantRunnerArgs: (assistantId: string) => Promise<IAssistantRunnerArgs>;

package/package.json

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

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

@@ -1,37 +0,0 @@
-import { z } from "zod";
-import type { IPeerDevice } from "../types/peer-device";
-import { type ITableDependencies, type ITableMetaData, Table } 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

@@ -1,189 +0,0 @@
-"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 context_1 = require("../context");
-const zod_types_1 = require("../types/zod-types");
-const utils_1 = require("../utils");
-const orm_1 = require("./orm");
-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);
-        const 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 changes = (await this.peerDevice.listChanges({
-            tableName: dataLocksTableMetaData.name,
-            recordId: lock.dataLockId,
-            op: "set", // V2 uses 'set' for updates
-        }));
-        // In V2, look for changes at path "/acknowledged" or full record changes at path "/"
-        const acknowledgedUpdates = changes
-            .map((change) => {
-            if (change.path === "/acknowledged") {
-                return change.value;
-            }
-            else if (change.path === "/" && change.value && typeof change.value === "object") {
-                return change.value.acknowledged;
-            }
-            return undefined;
-        })
-            .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((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

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

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

@@ -1,464 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteDB = require("better-sqlite3");
-const utils_1 = require("../utils");
-const data_locks_1 = require("./data-locks");
-const group_member_roles_1 = require("./group-member-roles");
-const sql_data_source_1 = require("./orm/sql.data-source");
-const types_1 = require("./orm/types");
-class DBHarness {
-    _db = null;
-    get database() {
-        if (!this._db) {
-            this._db = new SQLiteDB(":memory:");
-            this._db.pragma("journal_mode = WAL");
-        }
-        return this._db;
-    }
-    async get(sql, params = []) {
-        return this.database.prepare(sql).get(params);
-    }
-    async all(sql, params = []) {
-        return this.database.prepare(sql).all(params);
-    }
-    async exec(sql, params = []) {
-        const result = this.database.prepare(sql).run(params);
-        return { changes: result.changes };
-    }
-    async close() {
-        this._db?.close();
-        this._db = null;
-    }
-}
-// Mock peer device for testing
-class MockPeerDevice {
-    deviceId = "mock-device";
-    userId = "mock-user";
-    role = group_member_roles_1.GroupMemberRole.Owner;
-    connections = [];
-    changes = [];
-    constructor(connectionCount = 3) {
-        this.connections = Array.from({ length: connectionCount }, (_, i) => ({
-            deviceId: `peer-${i}`,
-            latencyMs: 50,
-            errorRate: 0,
-            timestampLastApplied: Date.now(),
-        }));
-    }
-    async getNetworkInfo() {
-        return {
-            deviceId: this.deviceId,
-            timestampLastApplied: Date.now(),
-            connections: this.connections,
-            preferredDeviceIds: [],
-            cpuPercent: 10,
-            memPercent: 10,
-            connectionSlotsAvailable: 10,
-        };
-    }
-    async listChanges(query) {
-        if (!query)
-            return this.changes;
-        return this.changes.filter((change) => change.tableName === query.tableName &&
-            change.recordId === query.recordId &&
-            change.op === query.op);
-    }
-    async notifyOfChanges(_deviceId, _timestampLastApplied) {
-        // Mock implementation
-    }
-    async downloadFileChunk(_chunkHash) {
-        // Mock implementation - return null to indicate chunk not found
-        return null;
-    }
-    async getFileChunkInfo(_chunkHash) {
-        // Mock implementation - return that we don't have the chunk
-        return { hasChunk: false };
-    }
-    addAcknowledgment(recordId, acknowledged) {
-        this.changes.push({
-            changeId: (0, utils_1.newid)(),
-            tableName: "DataLocks",
-            recordId,
-            op: "set",
-            path: "/acknowledged",
-            value: acknowledged,
-            createdAt: Date.now(),
-            appliedAt: Date.now(),
-        });
-    }
-    setConnectionCount(count) {
-        this.connections = Array.from({ length: count }, (_, i) => ({
-            deviceId: `peer-${i}`,
-            latencyMs: 50,
-            errorRate: 0,
-            timestampLastApplied: Date.now(),
-        }));
-    }
-    sendDeviceMessage(_message) {
-        throw new Error("Method not implemented.");
-    }
-}
-describe("data-locks.ts", () => {
-    const fiveMinutesMs = 5 * 60 * 1000;
-    jest.setTimeout(fiveMinutesMs);
-    let db;
-    let dataSource;
-    let dataLocksTable;
-    let mockPeerDevice;
-    const dataLocksTableMetaData = {
-        name: "DataLocks",
-        primaryKeyName: "dataLockId",
-        description: "Data locks table to track exclusive write access to records in other tables.",
-        fields: (0, types_1.schemaToFields)(data_locks_1.dataLockSchema),
-        indexes: [{ fields: ["recordId"] }],
-    };
-    beforeAll(async () => {
-        db = new DBHarness();
-        dataSource = new sql_data_source_1.SQLDataSource(db, dataLocksTableMetaData);
-        const mockDataContextForRegistry = {
-            dataContextId: "data-locks-test",
-        };
-        const { EventRegistry } = require("./orm/event-registry");
-        const eventRegistry = new EventRegistry(mockDataContextForRegistry);
-        const _mockDataContext = {
-            dataSourceFactory: () => dataSource,
-            eventRegistry: eventRegistry,
-        };
-        const deps = {
-            dataSource,
-            eventRegistry,
-            schema: data_locks_1.dataLockSchema,
-        };
-        dataLocksTable = new data_locks_1.DataLocksTable(dataLocksTableMetaData, deps);
-        mockPeerDevice = new MockPeerDevice();
-        dataLocksTable.peerDevice = mockPeerDevice;
-        await dataSource.dropTableIfExists();
-    });
-    afterAll(async () => {
-        await db.close();
-    });
-    beforeEach(async () => {
-        // Clean up any existing locks before each test
-        const allLocks = await dataLocksTable.list();
-        for (const lock of allLocks) {
-            await dataLocksTable.delete(lock);
-        }
-        mockPeerDevice.setConnectionCount(3);
-    });
-    describe("DataLocksTable", () => {
-        describe("constructor", () => {
-            it("should create a DataLocksTable instance with default constants", () => {
-                expect(dataLocksTable.DEFAULT_LOCK_TIME_MS).toBe(300_000); // 5 minutes
-                expect(dataLocksTable.DEFAULT_TIMEOUT_MS).toBe(20_000); // 20 seconds
-                expect(dataLocksTable.DEAD_PERIOD_MS).toBe(10_000); // 10 seconds
-            });
-            it("should have peerDevice property", () => {
-                expect(dataLocksTable.peerDevice).toBeDefined();
-            });
-        });
-        describe("getCurrentLock", () => {
-            it("should return undefined when no locks exist for recordId", async () => {
-                const result = await dataLocksTable.getCurrentLock("nonexistent-record");
-                expect(result).toBeUndefined();
-            });
-            it("should return undefined when only expired locks exist", async () => {
-                const recordId = (0, utils_1.newid)();
-                const expiredLock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId,
-                    lockedUntil: Date.now() - 1000, // Expired 1 second ago
-                };
-                await dataLocksTable.insert(expiredLock);
-                const result = await dataLocksTable.getCurrentLock(recordId);
-                expect(result).toBeUndefined();
-            });
-            it("should return the current valid lock", async () => {
-                const recordId = (0, utils_1.newid)();
-                const validLock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId,
-                    lockedUntil: Date.now() + 60000, // Expires in 1 minute
-                };
-                await dataLocksTable.insert(validLock);
-                const result = await dataLocksTable.getCurrentLock(recordId);
-                expect(result).toEqual(validLock);
-            });
-            it("should return the earliest lock when multiple valid locks exist", async () => {
-                const recordId = (0, utils_1.newid)();
-                const lock1 = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId,
-                    lockedUntil: Date.now() + 60000,
-                };
-                const lock2 = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId,
-                    lockedUntil: Date.now() + 60000,
-                };
-                // Insert them in order so we can predict which should be first
-                const firstLock = lock1.dataLockId < lock2.dataLockId ? lock1 : lock2;
-                const secondLock = lock1.dataLockId < lock2.dataLockId ? lock2 : lock1;
-                await dataLocksTable.insert(secondLock);
-                await dataLocksTable.insert(firstLock);
-                const result = await dataLocksTable.getCurrentLock(recordId);
-                expect(result?.dataLockId).toBe(firstLock.dataLockId);
-            });
-        });
-        describe("releaseLock", () => {
-            it("should delete the lock from the database", async () => {
-                const lock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId: (0, utils_1.newid)(),
-                    lockedUntil: Date.now() + 60000,
-                };
-                await dataLocksTable.insert(lock);
-                expect(await dataLocksTable.get(lock.dataLockId)).toEqual(lock);
-                await dataLocksTable.releaseLock(lock);
-                expect(await dataLocksTable.get(lock.dataLockId)).toBeUndefined();
-            });
-        });
-        describe("acquireLock", () => {
-            it("should acquire a lock when no existing locks", async () => {
-                const recordId = (0, utils_1.newid)();
-                // Mock sufficient acknowledgments for lock confirmation
-                const mockAcquireLock = jest.spyOn(dataLocksTable, "acquireLock");
-                mockAcquireLock.mockImplementation(async () => {
-                    const lock = {
-                        dataLockId: (0, utils_1.newid)(),
-                        recordId,
-                        lockedUntil: Date.now() + dataLocksTable.DEFAULT_LOCK_TIME_MS,
-                    };
-                    await dataLocksTable.insert(lock);
-                    return lock;
-                });
-                const result = await dataLocksTable.acquireLock(recordId);
-                expect(result).toBeDefined();
-                expect(result?.recordId).toBe(recordId);
-                expect(result?.lockedUntil).toBeGreaterThan(Date.now());
-                mockAcquireLock.mockRestore();
-            });
-            it("should use custom timeout and lock time", async () => {
-                const recordId = (0, utils_1.newid)();
-                const customTimeout = 5000;
-                const customLockTime = 120000;
-                const mockAcquireLock = jest.spyOn(dataLocksTable, "acquireLock");
-                mockAcquireLock.mockImplementation(async (recordId, timeoutMs, lockTimeMs) => {
-                    expect(timeoutMs).toBe(customTimeout);
-                    expect(lockTimeMs).toBe(customLockTime);
-                    return {
-                        dataLockId: (0, utils_1.newid)(),
-                        recordId,
-                        lockedUntil: Date.now() + (lockTimeMs || dataLocksTable.DEFAULT_LOCK_TIME_MS),
-                    };
-                });
-                await dataLocksTable.acquireLock(recordId, customTimeout, customLockTime);
-                mockAcquireLock.mockRestore();
-            });
-        });
-        describe("renewLock", () => {
-            it("should renew a valid lock", async () => {
-                const lock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId: (0, utils_1.newid)(),
-                    lockedUntil: Date.now() + 60000, // 1 minute from now
-                };
-                await dataLocksTable.insert(lock);
-                const originalLockedUntil = lock.lockedUntil;
-                // Small delay to ensure time difference
-                const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-                await sleep(10);
-                const renewedLock = await dataLocksTable.renewLock(lock, 120000);
-                expect(renewedLock).toBeDefined();
-                expect(renewedLock?.lockedUntil).toBeGreaterThan(originalLockedUntil);
-            });
-            it("should reject renewal of expired lock", async () => {
-                const lock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId: (0, utils_1.newid)(),
-                    lockedUntil: Date.now() - 20000, // Expired 20 seconds ago (beyond DEAD_PERIOD_MS)
-                };
-                await dataLocksTable.insert(lock);
-                const result = await dataLocksTable.renewLock(lock);
-                expect(result).toBeUndefined();
-            });
-            it("should reject renewal when lock is no longer current", async () => {
-                const recordId = (0, utils_1.newid)();
-                // getCurrentLock returns the lock with the lexicographically first dataLockId,
-                // so ensure newLockId sorts before oldLockId
-                const [newLockId, oldLockId] = [(0, utils_1.newid)(), (0, utils_1.newid)()].sort();
-                const oldLock = {
-                    dataLockId: oldLockId,
-                    recordId,
-                    lockedUntil: Date.now() + 60000,
-                };
-                const newLock = {
-                    dataLockId: newLockId,
-                    recordId,
-                    lockedUntil: Date.now() + 60000,
-                };
-                await dataLocksTable.insert(oldLock);
-                await dataLocksTable.insert(newLock);
-                // Try to renew the old lock - should fail because new lock is current (sorts first)
-                const result = await dataLocksTable.renewLock(oldLock);
-                expect(result).toBeUndefined();
-            });
-        });
-        describe("lockStatus", () => {
-            it("should return confirmed when sufficient acknowledgments", async () => {
-                const lock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId: (0, utils_1.newid)(),
-                    lockedUntil: Date.now() + 60000,
-                };
-                // Add sufficient acknowledgments (need 4 for 3 connections: Math.ceil(3 * 0.7) + 1 = 4)
-                mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now());
-                mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now() + 1);
-                mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now() + 2);
-                mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now() + 3);
-                const status = await dataLocksTable.lockStatus(lock);
-                expect(status).toBe("confirmed");
-            });
-            it("should return pending when insufficient acknowledgments", async () => {
-                const lock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId: (0, utils_1.newid)(),
-                    lockedUntil: Date.now() + 60000,
-                };
-                // Add insufficient acknowledgments (only 1, need 4)
-                mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now());
-                const status = await dataLocksTable.lockStatus(lock);
-                expect(status).toBe("pending");
-            });
-            it("should calculate acknowledgments needed correctly for different network sizes", async () => {
-                const lock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId: (0, utils_1.newid)(),
-                    lockedUntil: Date.now() + 60000,
-                };
-                // Test with 1 connection (need Math.ceil(1 * 0.7) + 1 = 2 acknowledgments)
-                mockPeerDevice.setConnectionCount(1);
-                mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now());
-                mockPeerDevice.addAcknowledgment(lock.dataLockId, Date.now() + 1);
-                let status = await dataLocksTable.lockStatus(lock);
-                expect(status).toBe("confirmed");
-                // Test with 5 connections (need Math.ceil(5 * 0.7) + 1 = 5 acknowledgments)
-                mockPeerDevice.setConnectionCount(5);
-                status = await dataLocksTable.lockStatus(lock);
-                expect(status).toBe("pending"); // Still only 2 acknowledgments, need 5
-            });
-            it("should throw error when peerDevice is not set", async () => {
-                const lock = {
-                    dataLockId: (0, utils_1.newid)(),
-                    recordId: (0, utils_1.newid)(),
-                    lockedUntil: Date.now() + 60000,
-                };
-                const originalPeerDevice = dataLocksTable.peerDevice;
-                dataLocksTable.peerDevice = undefined;
-                await expect(dataLocksTable.lockStatus(lock)).rejects.toThrow("Peer device not set for DataLocksTable");
-                dataLocksTable.peerDevice = originalPeerDevice;
-            });
-        });
-    });
-    describe("dataLockSchema", () => {
-        it("should validate valid lock data", () => {
-            const validLock = {
-                dataLockId: (0, utils_1.newid)(),
-                recordId: "test-record",
-                lockedUntil: Date.now() + 60000,
-            };
-            const result = data_locks_1.dataLockSchema.safeParse(validLock);
-            expect(result.success).toBe(true);
-        });
-        it("should validate lock with acknowledgment", () => {
-            const validLock = {
-                dataLockId: (0, utils_1.newid)(),
-                recordId: "test-record",
-                lockedUntil: Date.now() + 60000,
-                acknowledged: Date.now(),
-            };
-            const result = data_locks_1.dataLockSchema.safeParse(validLock);
-            expect(result.success).toBe(true);
-        });
-        it("should reject invalid lock data", () => {
-            const invalidLock = {
-                dataLockId: 123, // Should be string
-                recordId: "test-record",
-                lockedUntil: "invalid", // Should be number
-            };
-            const result = data_locks_1.dataLockSchema.safeParse(invalidLock);
-            expect(result.success).toBe(false);
-        });
-        it("should reject missing required fields", () => {
-            const incompleteLock = {
-                dataLockId: (0, utils_1.newid)(),
-                // Missing recordId and lockedUntil
-            };
-            const result = data_locks_1.dataLockSchema.safeParse(incompleteLock);
-            expect(result.success).toBe(false);
-        });
-    });
-    describe("DataLocks factory function", () => {
-        it("should return a DataLocksTable instance", () => {
-            // This is a simplified test - in practice you'd need to set up the factory properly
-            expect(typeof data_locks_1.DataLocks).toBe("function");
-        });
-    });
-    describe("integration scenarios", () => {
-        it("should handle concurrent lock attempts", async () => {
-            const recordId = (0, utils_1.newid)();
-            // This is a simplified version - real concurrent testing would require more complex setup
-            const mockInsert = jest.spyOn(dataLocksTable, "insert");
-            let insertCount = 0;
-            mockInsert.mockImplementation(async (lock) => {
-                insertCount++;
-                return { ...lock, dataLockId: `lock-${insertCount}` };
-            });
-            const promises = [
-                dataLocksTable.insert({ dataLockId: (0, utils_1.newid)(), recordId, lockedUntil: Date.now() + 60000 }),
-                dataLocksTable.insert({ dataLockId: (0, utils_1.newid)(), recordId, lockedUntil: Date.now() + 60000 }),
-                dataLocksTable.insert({ dataLockId: (0, utils_1.newid)(), recordId, lockedUntil: Date.now() + 60000 }),
-            ];
-            const results = await Promise.all(promises);
-            expect(results).toHaveLength(3);
-            expect(insertCount).toBe(3);
-            mockInsert.mockRestore();
-        });
-        it("should handle lock expiration cleanup", async () => {
-            const recordId = (0, utils_1.newid)();
-            const expiredLock = {
-                dataLockId: (0, utils_1.newid)(),
-                recordId,
-                lockedUntil: Date.now() - 1000, // Expired
-            };
-            const validLock = {
-                dataLockId: (0, utils_1.newid)(),
-                recordId,
-                lockedUntil: Date.now() + 60000, // Valid
-            };
-            await dataLocksTable.insert(expiredLock);
-            await dataLocksTable.insert(validLock);
-            const currentLock = await dataLocksTable.getCurrentLock(recordId);
-            expect(currentLock?.dataLockId).toBe(validLock.dataLockId);
-        });
-        it("should handle multiple records with independent locks", async () => {
-            const record1 = (0, utils_1.newid)();
-            const record2 = (0, utils_1.newid)();
-            const lock1 = {
-                dataLockId: (0, utils_1.newid)(),
-                recordId: record1,
-                lockedUntil: Date.now() + 60000,
-            };
-            const lock2 = {
-                dataLockId: (0, utils_1.newid)(),
-                recordId: record2,
-                lockedUntil: Date.now() + 60000,
-            };
-            await dataLocksTable.insert(lock1);
-            await dataLocksTable.insert(lock2);
-            const currentLock1 = await dataLocksTable.getCurrentLock(record1);
-            const currentLock2 = await dataLocksTable.getCurrentLock(record2);
-            expect(currentLock1?.dataLockId).toBe(lock1.dataLockId);
-            expect(currentLock2?.dataLockId).toBe(lock2.dataLockId);
-        });
-    });
-});