@peers-app/peers-sdk 0.15.4 → 0.16.0

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);
-        });
-    });
-});