@peers-app/peers-sdk 0.1.4

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

@@ -0,0 +1,456 @@
+"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 sql_data_source_1 = require("./orm/sql.data-source");
+const types_1 = require("./orm/types");
+const group_member_roles_1 = require("./group-member-roles");
+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 = []) {
+        this.database.prepare(sql).run(params);
+    }
+    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: []
+        };
+    }
+    async listChanges(query) {
+        if (!query)
+            return this.changes;
+        return this.changes.filter(change => change.tableName === query.tableName &&
+            change.recordId === query.recordId &&
+            change.changeType === query.changeType);
+    }
+    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,
+            changeType: 'update',
+            newRecord: { acknowledged },
+            timestamp: Date.now(),
+            timestampApplied: Date.now(),
+            jsonDiff: []
+        });
+    }
+    setConnectionCount(count) {
+        this.connections = Array.from({ length: count }, (_, i) => ({
+            deviceId: `peer-${i}`,
+            latencyMs: 50,
+            errorRate: 0,
+            timestampLastApplied: Date.now()
+        }));
+    }
+}
+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)();
+                const oldLock = {
+                    dataLockId: 'old-lock',
+                    recordId,
+                    lockedUntil: Date.now() + 60000,
+                };
+                const newLock = {
+                    dataLockId: 'new-lock', // Lexicographically later, but inserted after
+                    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
+                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);
+        });
+    });
+});

package/dist/data/device-sync-info.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { ITableMetaData } from "./orm";
+import type { DataContext } from "../context/data-context";
+export declare const deviceSyncInfoSchema: z.ZodObject<{
+    deviceId: z.ZodEffects<z.ZodString, string, string>;
+    timestampAppliedLast: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    deviceId: string;
+    timestampAppliedLast: number;
+}, {
+    deviceId: string;
+    timestampAppliedLast: number;
+}>;
+export type IDeviceSyncInfo = z.infer<typeof deviceSyncInfoSchema>;
+export declare const deviceSyncInfoMetaData: ITableMetaData;
+export declare function DeviceSyncInfos(dataContext?: DataContext): import("./orm").Table<{
+    deviceId: string;
+    timestampAppliedLast: number;
+}>;

package/dist/data/device-sync-info.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceSyncInfoMetaData = exports.deviceSyncInfoSchema = void 0;
+exports.DeviceSyncInfos = DeviceSyncInfos;
+const zod_1 = require("zod");
+const zod_types_1 = require("../types/zod-types");
+const orm_1 = require("./orm");
+const context_1 = require("../context");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+exports.deviceSyncInfoSchema = zod_1.z.object({
+    deviceId: zod_types_1.zodPeerId,
+    timestampAppliedLast: zod_1.z.number(),
+});
+exports.deviceSyncInfoMetaData = {
+    name: 'DeviceSyncTracking',
+    primaryKeyName: 'deviceId',
+    description: 'Sync tracking table',
+    fields: (0, orm_1.schemaToFields)(exports.deviceSyncInfoSchema),
+    localOnly: true,
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(exports.deviceSyncInfoMetaData, exports.deviceSyncInfoSchema);
+function DeviceSyncInfos(dataContext) {
+    return (0, context_1.getTableContainer)(dataContext).getTable(exports.deviceSyncInfoMetaData, exports.deviceSyncInfoSchema);
+}

package/dist/data/devices.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { TrustLevel } from "../device/socket.type";
+import type { DataContext } from "../context/data-context";
+export declare const deviceSchema: z.ZodObject<{
+    deviceId: z.ZodString;
+    userId: z.ZodString;
+    firstSeen: z.ZodDate;
+    lastSeen: z.ZodDate;
+    name: z.ZodOptional<z.ZodString>;
+    serverUrl: z.ZodOptional<z.ZodString>;
+    trustLevel: z.ZodNativeEnum<typeof TrustLevel>;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    trustLevel: TrustLevel;
+    deviceId: string;
+    firstSeen: Date;
+    lastSeen: Date;
+    name?: string | undefined;
+    serverUrl?: string | undefined;
+}, {
+    userId: string;
+    trustLevel: TrustLevel;
+    deviceId: string;
+    firstSeen: Date;
+    lastSeen: Date;
+    name?: string | undefined;
+    serverUrl?: string | undefined;
+}>;
+export type IDevice = z.infer<typeof deviceSchema>;
+export interface IDeviceInfo {
+    userId: string;
+    deviceId: string;
+    publicKey: string;
+    publicBoxKey: string;
+}
+export interface IDeviceHandshake extends IDeviceInfo {
+    connectionId: string;
+    serverAddress: string;
+    timestamp: number;
+}
+export declare function Devices(dataContext?: DataContext): import("./orm").Table<{
+    userId: string;
+    trustLevel: TrustLevel;
+    deviceId: string;
+    firstSeen: Date;
+    lastSeen: Date;
+    name?: string | undefined;
+    serverUrl?: string | undefined;
+}>;
+export declare const trustedServers: import("./persistent-vars").PersistentVar<string[]>;
+export declare const thisDeviceId: import("./persistent-vars").PersistentVar<string>;

package/dist/data/devices.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thisDeviceId = exports.trustedServers = exports.deviceSchema = void 0;
+exports.Devices = Devices;
+const zod_1 = require("zod");
+const types_1 = require("./orm/types");
+const persistent_vars_1 = require("./persistent-vars");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const socket_type_1 = require("../device/socket.type");
+exports.deviceSchema = zod_1.z.object({
+    deviceId: zod_1.z.string(),
+    userId: zod_1.z.string(),
+    firstSeen: zod_1.z.date(),
+    lastSeen: zod_1.z.date(),
+    name: zod_1.z.string().optional(),
+    serverUrl: zod_1.z.string().optional(),
+    trustLevel: zod_1.z.nativeEnum(socket_type_1.TrustLevel),
+});
+const metaData = {
+    name: 'Devices',
+    description: 'The Peer devices that this computer is aware of',
+    primaryKeyName: 'deviceId',
+    fields: (0, types_1.schemaToFields)(exports.deviceSchema),
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.deviceSchema);
+function Devices(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.deviceSchema);
+}
+exports.trustedServers = (0, persistent_vars_1.groupVar)('trustedServers', {
+    defaultValue: [
+        'https://peers.app',
+        'https://peers-services.azurewebsites.net',
+    ],
+});
+exports.thisDeviceId = (0, persistent_vars_1.deviceVar)('thisDeviceId');

package/dist/data/embeddings.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
+export declare const embeddingSchema: z.ZodObject<{
+    embeddingId: z.ZodString;
+    textHash: z.ZodString;
+    embedding: z.ZodArray<z.ZodNumber, "many">;
+    embeddingType: z.ZodString;
+    metadata: z.ZodObject<{
+        fkId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodAny, z.objectOutputType<{
+        fkId: z.ZodOptional<z.ZodString>;
+    }, z.ZodAny, "strip">, z.objectInputType<{
+        fkId: z.ZodOptional<z.ZodString>;
+    }, z.ZodAny, "strip">>;
+}, "strip", z.ZodTypeAny, {
+    metadata: {
+        fkId?: string | undefined;
+    } & {
+        [k: string]: any;
+    };
+    embeddingId: string;
+    textHash: string;
+    embedding: number[];
+    embeddingType: string;
+}, {
+    metadata: {
+        fkId?: string | undefined;
+    } & {
+        [k: string]: any;
+    };
+    embeddingId: string;
+    textHash: string;
+    embedding: number[];
+    embeddingType: string;
+}>;
+export type IEmbedding = z.infer<typeof embeddingSchema>;
+export declare function Embeddings(dataContext?: DataContext): import("./orm").Table<{
+    metadata: {
+        fkId?: string | undefined;
+    } & {
+        [k: string]: any;
+    };
+    embeddingId: string;
+    textHash: string;
+    embedding: number[];
+    embeddingType: string;
+}>;

package/dist/data/embeddings.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embeddingSchema = void 0;
+exports.Embeddings = Embeddings;
+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.embeddingSchema = zod_1.z.object({
+    embeddingId: zod_1.z.string(),
+    textHash: zod_1.z.string().describe('The hash of the text'),
+    embedding: zod_1.z.array(zod_1.z.number()).describe('The embedding of the text'),
+    embeddingType: zod_1.z.string().describe('The type of embedding used'),
+    metadata: zod_1.z.object({
+        fkId: zod_1.z.string().optional(),
+        // fkTable: z.string().optional(),
+        // fkIdFieldName: z.string().optional(),
+    }).catchall(zod_1.z.any()).describe('Any metadata associated with the embedding'),
+});
+const metaData = {
+    name: 'Embeddings',
+    description: 'The embeddings for some specific text',
+    primaryKeyName: 'embeddingId',
+    fields: (0, types_1.schemaToFields)(exports.embeddingSchema),
+    indexes: [
+        {
+            fields: ['textHash', 'embeddingType'],
+            unique: true,
+        },
+    ],
+    localOnly: true,
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.embeddingSchema);
+function Embeddings(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.embeddingSchema);
+}