@peers-app/peers-sdk 0.8.19 → 0.9.0

package/dist/context/user-context-singleton.d.ts

@@ -9,3 +9,4 @@ export declare function setDefaultClientUserContext(userId: string): void;
 export declare function getAllTables(): {
     [tableName: string]: Table<any>;
 };
+export declare const myUserId: () => string;

package/dist/context/user-context-singleton.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.myUserId = void 0;
 exports.getUserContext = getUserContext;
 exports.setUserContext = setUserContext;
 exports.getDefaultDataContext = getDefaultDataContext;
@@ -103,3 +104,10 @@ if (!rpc_types_1.isClient) {
         return table[methodName](...args);
     };
 }
+const myUserId = () => {
+    if (!userContextInstance) {
+        throw new Error(`myUserId called before userContext singleton was initialized`);
+    }
+    return userContextInstance.userId;
+};
+exports.myUserId = myUserId;

package/dist/context/user-context.js

@@ -90,6 +90,9 @@ class UserContext {
                 this.currentlyActiveGroupId(group.dataContextId);
             }
         });
+        if (!this.currentlyActiveGroupId()) {
+            this.currentlyActiveGroupId(this.defaultDataContext().dataContextId || this.userId);
+        }
     }
     getDataContext(groupId) {
         if (!groupId || groupId === this.userId) {

package/dist/data/assistants.d.ts

@@ -11,7 +11,7 @@ export declare const assistantSchema: z.ZodObject<{
     createdAt: z.ZodDefault<z.ZodDate>;
     updatedAt: z.ZodOptional<z.ZodDate>;
     description: z.ZodOptional<z.ZodString>;
-    assistantRunnerToolId: z.ZodDefault<z.ZodString>;
+    assistantRunnerToolId: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
     assistantRunnerConfig: z.ZodDefault<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
     toolsToInclude: z.ZodDefault<z.ZodString>;
     toolInclusionStrategy: z.ZodDefault<z.ZodNativeEnum<typeof ToolInclusionStrategy>>;

package/dist/data/assistants.js

@@ -23,7 +23,7 @@ exports.assistantSchema = zod_1.z.object({
     createdAt: zod_1.z.date().default(() => new Date()),
     updatedAt: zod_1.z.date().optional(),
     description: zod_1.z.string().optional().describe(`Information about the assistant that won't be used in the interaction but can still be used to differentiate between assistants`),
-    assistantRunnerToolId: zod_1.z.string().default(system_ids_1.defaultAssistantRunnerToolId).describe('The tool id of the model to use to run the assistant'),
+    assistantRunnerToolId: zod_types_1.zodPeerId.default(system_ids_1.defaultAssistantRunnerToolId).describe('The tool id of the model to use to run the assistant'),
     assistantRunnerConfig: zod_types_1.zodAnyObject.default({}).describe('The configuration to use when running the assistant'),
     toolsToInclude: zod_1.z.string().default('').describe('Link the tools that should always be available to this assistant.  Only linked tools will be included.  All other content will be ignored.\n\nex: `$hello-world-tool`'),
     // toolsToExclude: z.string().optional().describe('Describe or link the tools that should never be available to this assistant'),

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

@@ -160,6 +160,14 @@ export declare class ChangeTrackingTable extends SQLDataSource<IChangeRecord> {
      * @param beforeTimestamp - Delete changes superseded before this timestamp
      */
     deleteChanges(changeIds: string[]): Promise<void>;
+    /**
+     * Clear inline values on insert changes (op='set', path='/') for a specific table.
+     * These values are no longer needed since they are resolved from the source table at query time.
+     * Used during compaction to reclaim space from pre-migration insert changes that still have inline values.
+     *
+     * @param tableName - Name of the table to clear insert values for
+     */
+    clearInsertChangeValues(tableName: string): Promise<void>;
     /**
      * Get table metadata
      */

package/dist/data/change-tracking.js

@@ -345,6 +345,24 @@ class ChangeTrackingTable extends orm_1.SQLDataSource {
       WHERE changeId IN (${changeIds.map(c => "?").join()})
     `, changeIds);
     }
+    /**
+     * Clear inline values on insert changes (op='set', path='/') for a specific table.
+     * These values are no longer needed since they are resolved from the source table at query time.
+     * Used during compaction to reclaim space from pre-migration insert changes that still have inline values.
+     *
+     * @param tableName - Name of the table to clear insert values for
+     */
+    async clearInsertChangeValues(tableName) {
+        await this.initTable();
+        await this.db.exec(`
+      UPDATE "${this.tableName}"
+      SET value = NULL
+      WHERE tableName = ?
+        AND op = 'set'
+        AND path = '/'
+        AND value IS NOT NULL
+    `, [tableName]);
+    }
     /**
      * Get table metadata
      */

package/dist/data/channels.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
 export declare const channelSchema: z.ZodObject<{
-    channelId: z.ZodString;
+    channelId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
     description: z.ZodString;
     createdAt: z.ZodDate;
-    owningGroupId: z.ZodString;
+    owningGroupId: z.ZodEffects<z.ZodString, string, string>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     description: string;

package/dist/data/channels.js

@@ -6,12 +6,13 @@ 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");
+const zod_types_1 = require("../types/zod-types");
 exports.channelSchema = zod_1.z.object({
-    channelId: zod_1.z.string(),
+    channelId: zod_types_1.zodPeerId,
     name: zod_1.z.string(),
     description: zod_1.z.string(),
     createdAt: zod_1.z.date(),
-    owningGroupId: zod_1.z.string(),
+    owningGroupId: zod_types_1.zodPeerId,
 });
 const metaData = {
     name: 'Channels',

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

@@ -22,7 +22,8 @@ class DBHarness {
         return this.database.prepare(sql).all(params);
     }
     async exec(sql, params = []) {
-        this.database.prepare(sql).run(params);
+        const result = this.database.prepare(sql).run(params);
+        return { changes: result.changes };
     }
     async close() {
         this._db?.close();
@@ -284,19 +285,22 @@ describe('data-locks.ts', () => {
             });
             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: 'old-lock',
+                    dataLockId: oldLockId,
                     recordId,
                     lockedUntil: Date.now() + 60000,
                 };
                 const newLock = {
-                    dataLockId: 'new-lock', // Lexicographically later, but inserted after
+                    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
+                // Try to renew the old lock - should fail because new lock is current (sorts first)
                 const result = await dataLocksTable.renewLock(oldLock);
                 expect(result).toBeUndefined();
             });

package/dist/data/devices.d.ts

@@ -2,8 +2,8 @@ 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;
+    deviceId: z.ZodEffects<z.ZodString, string, string>;
+    userId: z.ZodEffects<z.ZodString, string, string>;
     firstSeen: z.ZodDate;
     lastSeen: z.ZodDate;
     name: z.ZodOptional<z.ZodString>;

package/dist/data/devices.js

@@ -8,9 +8,10 @@ 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");
+const zod_types_1 = require("../types/zod-types");
 exports.deviceSchema = zod_1.z.object({
-    deviceId: zod_1.z.string(),
-    userId: zod_1.z.string(),
+    deviceId: zod_types_1.zodPeerId,
+    userId: zod_types_1.zodPeerId,
     firstSeen: zod_1.z.date(),
     lastSeen: zod_1.z.date(),
     name: zod_1.z.string().optional(),

package/dist/data/embeddings.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
 export declare const embeddingSchema: z.ZodObject<{
-    embeddingId: z.ZodString;
+    embeddingId: z.ZodEffects<z.ZodString, string, string>;
     textHash: z.ZodString;
     embedding: z.ZodArray<z.ZodNumber, "many">;
     embeddingType: z.ZodString;

package/dist/data/embeddings.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.embeddingSchema = void 0;
 exports.Embeddings = Embeddings;
 const zod_1 = require("zod");
+const zod_types_1 = require("../types/zod-types");
 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(),
+    embeddingId: zod_types_1.zodPeerId,
     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'),

package/dist/data/files/file.types.d.ts

@@ -1,14 +1,14 @@
 import { z } from "zod";
 import { ITableMetaData } from "../orm/types";
 export declare const fileSchema: z.ZodObject<{
-    fileId: z.ZodString;
+    fileId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
     fileSize: z.ZodNumber;
     fileHash: z.ZodString;
     mimeType: z.ZodOptional<z.ZodString>;
     chunkHashes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     isIndexFile: z.ZodOptional<z.ZodBoolean>;
-    indexFileId: z.ZodOptional<z.ZodString>;
+    indexFileId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     fileId: string;

package/dist/data/files/file.types.js

@@ -6,16 +6,17 @@ exports.setFileOps = setFileOps;
 exports.getFileOps = getFileOps;
 exports.resetFileOps = resetFileOps;
 const zod_1 = require("zod");
+const zod_types_1 = require("../../types/zod-types");
 const types_1 = require("../orm/types");
 exports.fileSchema = zod_1.z.object({
-    fileId: zod_1.z.string(),
+    fileId: zod_types_1.zodPeerId,
     name: zod_1.z.string().describe('The name of the file'),
     fileSize: zod_1.z.number().describe('The size of the file in bytes'),
     fileHash: zod_1.z.string().describe('Hash of the chunk hashes array for integrity verification'),
     mimeType: zod_1.z.string().optional().describe('The MIME type of the file'),
     chunkHashes: zod_1.z.array(zod_1.z.string()).optional().describe('SHA-256 hashes of each chunk in order (for small files)'),
     isIndexFile: zod_1.z.boolean().optional().describe('True if this is an index file for another large file'),
-    indexFileId: zod_1.z.string().optional().describe('FileId of index file (for large files)'),
+    indexFileId: zod_types_1.zodPeerId.optional().describe('FileId of index file (for large files)'),
 });
 exports.filesMetaData = {
     name: 'Files',

package/dist/data/groups.d.ts

@@ -10,7 +10,7 @@ export declare const groupSchema: z.ZodObject<{
     iconClassName: z.ZodOptional<z.ZodString>;
     publicRole: z.ZodOptional<z.ZodNativeEnum<typeof GroupMemberRole>>;
     disabled: z.ZodOptional<z.ZodBoolean>;
-    founderUserId: z.ZodString;
+    founderUserId: z.ZodEffects<z.ZodString, string, string>;
     signature: z.ZodString;
     publicKey: z.ZodString;
     publicBoxKey: z.ZodString;

package/dist/data/groups.js

@@ -52,7 +52,7 @@ exports.groupSchema = zod_1.z.object({
     iconClassName: zod_1.z.string().optional().describe('Icon class name for the group (e.g., bi-people-fill)'),
     publicRole: zod_1.z.nativeEnum(group_member_roles_1.GroupMemberRole).optional().describe('Whether the group is publicly readable'),
     disabled: zod_1.z.boolean().optional().describe('Whether the group is currently disabled'),
-    founderUserId: zod_1.z.string().describe('The user ID of the group founder'),
+    founderUserId: zod_types_1.zodPeerId.describe('The user ID of the group founder'),
     signature: zod_1.z.string().describe('The signed hash of this data excluding the signature itself'),
     publicKey: zod_1.z.string().describe('The public key of the group used to verify a data has come from a group member with write permissions or higher'),
     publicBoxKey: zod_1.z.string().describe('The public key used to encrypt data that only group members with writer permissions or higher can decrypt'),

package/dist/data/index.d.ts

@@ -19,6 +19,7 @@ export * from "./knowledge/predicates";
 export * from "./messages";
 export * from "./packages";
 export * from "./packages.utils";
+export * from "./table-definitions-table";
 export * from "./peer-events/peer-event-handlers";
 export * from "./peer-events/peer-event-types";
 export * from "./peer-events/peer-events";

package/dist/data/index.js

@@ -35,6 +35,7 @@ __exportStar(require("./knowledge/predicates"), exports);
 __exportStar(require("./messages"), exports);
 __exportStar(require("./packages"), exports);
 __exportStar(require("./packages.utils"), exports);
+__exportStar(require("./table-definitions-table"), exports);
 __exportStar(require("./peer-events/peer-event-handlers"), exports);
 __exportStar(require("./peer-events/peer-event-types"), exports);
 __exportStar(require("./peer-events/peer-events"), exports);

package/dist/data/messages.d.ts

@@ -2,14 +2,14 @@ import { z } from 'zod';
 import { DataContext } from "../context/data-context";
 export declare const messageSchema: z.ZodObject<{
     messageId: z.ZodEffects<z.ZodString, string, string>;
-    channelId: z.ZodString;
-    userId: z.ZodString;
-    messageParentId: z.ZodOptional<z.ZodString>;
-    assistantId: z.ZodOptional<z.ZodString>;
+    channelId: z.ZodEffects<z.ZodString, string, string>;
+    userId: z.ZodEffects<z.ZodString, string, string>;
+    messageParentId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    assistantId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     message: z.ZodString;
     createdAt: z.ZodDate;
     editedAt: z.ZodOptional<z.ZodDate>;
-    fileIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    fileIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
     vars: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
 }, "strip", z.ZodTypeAny, {
     message: string;

package/dist/data/messages.js

@@ -15,14 +15,14 @@ const user_context_singleton_1 = require("../context/user-context-singleton");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 exports.messageSchema = zod_1.z.object({
     messageId: zod_types_1.zodPeerId,
-    channelId: zod_1.z.string().describe('The id of the channel this message entry belongs to'),
-    userId: zod_1.z.string().describe('The id of the user who created this message entry'),
-    messageParentId: zod_1.z.string().optional().describe('The id of the parent message entry if this is part of a thread'),
-    assistantId: zod_1.z.string().optional().describe(`The id of the user's assistant that created this message entry operating on behalf of the user`),
+    channelId: zod_types_1.zodPeerId.describe('The id of the channel this message entry belongs to'),
+    userId: zod_types_1.zodPeerId.describe('The id of the user who created this message entry'),
+    messageParentId: zod_types_1.zodPeerId.optional().describe('The id of the parent message entry if this is part of a thread'),
+    assistantId: zod_types_1.zodPeerId.optional().describe(`The id of the user's assistant that created this message entry operating on behalf of the user`),
     message: zod_1.z.string().describe('The markdown content of this message entry'),
     createdAt: zod_1.z.date(),
     editedAt: zod_1.z.date().optional().describe('The time this message entry was last edited, if it was edited'),
-    fileIds: zod_1.z.string().array().optional().describe('The ids of files attached to this message entry'),
+    fileIds: zod_types_1.zodPeerId.array().optional().describe('The ids of files attached to this message entry'),
     vars: zod_types_1.zodAnyObject.optional().describe('The variables that are associated with this message entry'),
 });
 const metaData = {

package/dist/data/orm/dependency-injection.test.js

@@ -147,7 +147,9 @@ describe('Dependency Injection Pattern', () => {
         // Verify table was created correctly
         expect(table).toBeInstanceOf(_1.Table);
         expect(table.tableName).toBe('TestTable');
-        expect(table.schema).toBe(testSchema);
+        // Table merges fields-derived schema with code schema, so it's not the same reference
+        const testData = { id: 'test-id', name: 'test-name' };
+        expect(() => table.schema.parse(testData)).not.toThrow();
     });
     it('should create tables through TableFactory using new DI pattern internally', () => {
         // Create mock DataContext
@@ -165,7 +167,8 @@ describe('Dependency Injection Pattern', () => {
         // Verify table was created correctly through TableFactory
         expect(table).toBeInstanceOf(_1.Table);
         expect(table.tableName).toBe('TestTable');
-        expect(table.schema).toBe(testSchema);
+        // Table merges fields-derived schema with code schema, so it's not the same reference
+        expect(() => table.schema.parse({ id: 'test-id', name: 'test-name' })).not.toThrow();
         expect(table.metaData).toBe(testMetaData);
     });
 });

package/dist/data/orm/sql-db.d.ts

@@ -1,7 +1,9 @@
 export interface ISqlDb {
     get: (sql: string, params?: any) => Promise<any>;
     all: (sql: string, params?: any) => Promise<any[]>;
-    exec: (sql: string, params?: any) => Promise<void>;
+    exec: (sql: string, params?: any) => Promise<{
+        changes: number;
+    }>;
     close: () => Promise<void>;
     execSync?: (sql: string, params?: any) => void;
     getSync?: (sql: string, params?: any) => any;

package/dist/data/orm/sql.data-source.test.js

@@ -5,6 +5,7 @@ const lodash_1 = require("lodash");
 const zod_1 = require("zod");
 const utils_1 = require("../../utils");
 const field_type_1 = require("../../types/field-type");
+const zod_types_1 = require("../../types/zod-types");
 const sql_data_source_1 = require("./sql.data-source");
 const types_1 = require("./types");
 class DBHarness {
@@ -23,7 +24,8 @@ class DBHarness {
         return this.db.prepare(sql).all(params);
     }
     async exec(sql, params = []) {
-        await this.db.prepare(sql).run(params);
+        const result = await this.db.prepare(sql).run(params);
+        return { changes: result.changes };
     }
     async close() {
         this._db?.close();
@@ -39,12 +41,12 @@ describe('table', () => {
     });
     describe('when type is defined in code', () => {
         const taskSchema = zod_1.z.object({
-            taskId: zod_1.z.string().default(() => (0, utils_1.newid)()),
+            taskId: zod_types_1.zodPeerId.default(() => (0, utils_1.newid)()),
             title: zod_1.z.string(),
             body: zod_1.z.string().default(''),
             dueDate: zod_1.z.date().optional(),
             completeDT: zod_1.z.date().optional(),
-            parentTaskId: zod_1.z.string().optional(),
+            parentTaskId: zod_types_1.zodPeerId.optional(),
         });
         const taskFields = (0, types_1.schemaToFields)(taskSchema);
         const tasksTableType = {

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

@@ -2,11 +2,21 @@ import { z } from 'zod';
 import { ITableMetaData } from './types';
 import { Table } from './table';
 import { ITableDefinition, TableFactory, TableConstructor } from './table-definitions.type';
+import type { ITableDefinitionRecord } from '../table-definitions-table';
+/**
+ * Compare two table definition versions and decide whether to update.
+ * @returns 'update' to proceed, 'skip' to keep existing, 'update-warn-unversioned' to proceed with a warning,
+ *          'skip-warn-conflict' to skip with a warning about mismatched definitions at the same version.
+ */
+export declare function checkVersionedUpdate(existingVersion: number, incomingVersion: number, existingMetaData: any, incomingMetaData: any): 'update' | 'skip' | 'update-warn-unversioned' | 'skip-warn-conflict';
 export declare class TableContainer {
     readonly tableFactory: TableFactory;
     readonly groupId?: string | undefined;
     private readonly tableDefinitions;
     private tableInstances;
+    private savingDefinitions;
+    private readonly fallbackDefinitions;
+    private fallbackInstances;
     constructor(tableFactory: TableFactory, groupId?: string | undefined);
     registerTableDefinition<T extends {
         [key: string]: any;
@@ -26,11 +36,24 @@ export declare class TableContainer {
     getTable<T extends {
         [key: string]: any;
     }>(metaData: ITableMetaData, schema?: z.AnyZodObject, tableConstructor?: TableConstructor<T>): Table<T>;
+    /**
+     * Auto-save table definition to the TableDefinitions system table.
+     * Only runs on server side, only for tables with a tableId (skips system tables),
+     * and skips saving the TableDefinitions table itself to avoid recursion.
+     */
+    private saveTableDefinition;
     getTableByName<T extends {
         [key: string]: any;
     }>(tableName: string): Table<T>;
+    /**
+     * Register a table definition from a synced TableDefinitions record.
+     * These go into the fallback tier (no custom constructor) so they never
+     * block full code-defined instances from being created later.
+     */
+    registerFromTableDefinitionRecord(record: ITableDefinitionRecord): void;
     /**
      * This ensures all tables have been new'ed up and then returns the entire list of them.
+     * Full (code-defined) instances take precedence over fallback (synced-definition) instances.
      *
      * This is primarily intended to be used by the peer-device sync operation which needs all
      * tables to be able to apply changes correctly.