@peers-app/peers-sdk 0.8.23 → 0.9.1

package/dist/data/orm/types.test.js

@@ -4,6 +4,7 @@ const zod_1 = require("zod");
 const types_1 = require("./types");
 const field_type_1 = require("../../types/field-type");
 const utils_1 = require("../../utils");
+const zod_types_1 = require("../../types/zod-types");
 describe('types', () => {
     it('fieldsToSchema', () => {
         const someDate = new Date();
@@ -57,7 +58,7 @@ describe('types', () => {
         });
         const groupFields = (0, types_1.schemaToFields)(groupSchema);
         const groupFieldsExpected = [
-            { name: 'groupId', description: 'The id of the group', type: field_type_1.FieldType.id },
+            { name: 'groupId', description: 'The id of the group', type: field_type_1.FieldType.string },
             { name: 'groupName', description: 'The name of the group', type: field_type_1.FieldType.string },
             { name: 'groupDescription', description: 'The description of the group', type: field_type_1.FieldType.string },
             { name: 'createdAt', description: 'The date the group was created', type: field_type_1.FieldType.Date, }, //defaultValue: () => new Date() },
@@ -68,4 +69,138 @@ describe('types', () => {
         ];
         expect(groupFields).toEqual(groupFieldsExpected);
     });
+    it('schemaToFields should detect zodPeerId as FieldType.id', () => {
+        const schema = zod_1.z.object({
+            recordId: zod_types_1.zodPeerId.describe('A peer id field'),
+            optionalRef: zod_types_1.zodPeerId.optional().describe('An optional peer id'),
+        });
+        const fields = (0, types_1.schemaToFields)(schema);
+        expect(fields.find(f => f.name === 'recordId').type).toBe(field_type_1.FieldType.id);
+        expect(fields.find(f => f.name === 'optionalRef').type).toBe(field_type_1.FieldType.id);
+    });
+    it('schemaToFields should NOT classify plain z.string() as id just because name ends in Id', () => {
+        const schema = zod_1.z.object({
+            externalId: zod_1.z.string().describe('An external system identifier'),
+            channelId: zod_1.z.string().describe('A channel reference'),
+            name: zod_1.z.string().describe('A plain string'),
+        });
+        const fields = (0, types_1.schemaToFields)(schema);
+        expect(fields.find(f => f.name === 'externalId').type).toBe(field_type_1.FieldType.string);
+        expect(fields.find(f => f.name === 'channelId').type).toBe(field_type_1.FieldType.string);
+        expect(fields.find(f => f.name === 'name').type).toBe(field_type_1.FieldType.string);
+    });
+    it('schemaToFields should NOT classify a non-id string refinement as FieldType.id', () => {
+        const zodEmail = zod_1.z.string().refine(val => val.includes('@'), { message: 'Must be an email' });
+        const zodNonEmpty = zod_1.z.string().refine(val => val.length > 0, { message: 'Must not be empty' });
+        const schema = zod_1.z.object({
+            email: zodEmail.describe('An email address'),
+            requiredField: zodNonEmpty.describe('A non-empty string'),
+            peerId: zod_types_1.zodPeerId.describe('A real peer id'),
+        });
+        const fields = (0, types_1.schemaToFields)(schema);
+        expect(fields.find(f => f.name === 'email').type).toBe(field_type_1.FieldType.string);
+        expect(fields.find(f => f.name === 'requiredField').type).toBe(field_type_1.FieldType.string);
+        expect(fields.find(f => f.name === 'peerId').type).toBe(field_type_1.FieldType.id);
+    });
+    it('fieldsToSchema should merge with optional code schema for most-constrained validation', () => {
+        const codeSchema = zod_1.z.object({
+            recordId: zod_types_1.zodPeerId.describe('A peer id'),
+            label: zod_1.z.string().min(1).describe('Non-empty label'),
+        });
+        const fields = [
+            { name: 'recordId', description: 'A peer id', type: field_type_1.FieldType.string },
+            { name: 'label', description: 'Non-empty label', type: field_type_1.FieldType.string },
+        ];
+        const mergedSchema = (0, types_1.fieldsToSchema)(fields, codeSchema);
+        const validId = (0, utils_1.newid)();
+        // Valid peer id should pass the merged schema
+        expect(() => mergedSchema.parse({ recordId: validId, label: 'hello' })).not.toThrow();
+        // Empty string should fail: the code schema's zodPeerId rejects it
+        expect(() => mergedSchema.parse({ recordId: '', label: 'hello' })).toThrow();
+        // Empty label should fail: the code schema's .min(1) rejects it
+        expect(() => mergedSchema.parse({ recordId: validId, label: '' })).toThrow();
+    });
+    it('round-trip: fieldsToSchema id fields should survive schemaToFields detection', () => {
+        // fieldsToSchema creates z.string().refine(isid) for FieldType.id fields.
+        // schemaToFields should detect that refinement as FieldType.id so round-trips are consistent.
+        const fields = [
+            { name: 'recordId', description: 'A peer id', type: field_type_1.FieldType.id },
+            { name: 'label', description: 'A label', type: field_type_1.FieldType.string },
+        ];
+        const schema = (0, types_1.fieldsToSchema)(fields);
+        const roundTrippedFields = (0, types_1.schemaToFields)(schema);
+        expect(roundTrippedFields.find(f => f.name === 'recordId').type).toBe(field_type_1.FieldType.id);
+        expect(roundTrippedFields.find(f => f.name === 'label').type).toBe(field_type_1.FieldType.string);
+    });
+    it('fieldsToSchema merge should handle optional zodPeerId fields correctly', () => {
+        const codeSchema = zod_1.z.object({
+            ownerId: zod_types_1.zodPeerId.describe('The owner'),
+            referrerId: zod_types_1.zodPeerId.optional().describe('Optional referrer'),
+        });
+        const fields = [
+            { name: 'ownerId', description: 'The owner', type: field_type_1.FieldType.string },
+            { name: 'referrerId', description: 'Optional referrer', type: field_type_1.FieldType.string, optional: true },
+        ];
+        const mergedSchema = (0, types_1.fieldsToSchema)(fields, codeSchema);
+        const validId = (0, utils_1.newid)();
+        const validId2 = (0, utils_1.newid)();
+        // Both provided and valid
+        expect(() => mergedSchema.parse({ ownerId: validId, referrerId: validId2 })).not.toThrow();
+        // Optional field omitted
+        expect(() => mergedSchema.parse({ ownerId: validId })).not.toThrow();
+        // Optional field present but invalid
+        expect(() => mergedSchema.parse({ ownerId: validId, referrerId: 'not-a-valid-id' })).toThrow();
+        // Required field missing
+        expect(() => mergedSchema.parse({ referrerId: validId })).toThrow();
+        // Required field invalid
+        expect(() => mergedSchema.parse({ ownerId: 'bad', referrerId: validId })).toThrow();
+    });
+    it('initRecord pattern: code schema defaults should work even after JSON round-trip of fields', () => {
+        const codeSchema = zod_1.z.object({
+            recordId: zod_types_1.zodPeerId.describe('A peer id'),
+            label: zod_1.z.string().default('untitled').describe('A label with default'),
+            createdAt: zod_1.z.date().default(() => new Date()).describe('Date with factory default'),
+            count: zod_1.z.number().default(0).describe('A count with default'),
+        });
+        // Simulate the real flow: code schema -> fields -> JSON (sync) -> parse back
+        const fields = (0, types_1.schemaToFields)(codeSchema);
+        const fieldsAfterJson = JSON.parse(JSON.stringify(fields));
+        // Function defaults like () => new Date() are lost through JSON
+        const mergedSchema = (0, types_1.fieldsToSchema)(fieldsAfterJson, codeSchema);
+        const validId = (0, utils_1.newid)();
+        const data = { recordId: validId };
+        // Simulate what Table.initRecord does: apply code schema first for defaults,
+        // then fall back to merged schema
+        const defaults = {};
+        const shape = codeSchema.shape;
+        for (const field of fieldsAfterJson) {
+            if (shape[field.name]) {
+                const codeValue = shape[field.name].safeParse(data[field.name]);
+                if (codeValue.success) {
+                    defaults[field.name] = codeValue.data;
+                    continue;
+                }
+            }
+            const zodField = mergedSchema.shape[field.name];
+            const value = zodField.safeParse(data[field.name]);
+            if (value.success) {
+                defaults[field.name] = value.data;
+            }
+        }
+        const result = { ...defaults, ...data };
+        expect(result.label).toBe('untitled');
+        expect(result.createdAt).toBeInstanceOf(Date);
+        expect(result.count).toBe(0);
+        expect(result.recordId).toBe(validId);
+    });
+    it('fieldsToSchema without code schema should work as before', () => {
+        const fields = [
+            { name: 'recordId', description: 'A peer id', type: field_type_1.FieldType.id },
+            { name: 'label', description: 'A label', type: field_type_1.FieldType.string },
+        ];
+        const schema = (0, types_1.fieldsToSchema)(fields);
+        const validId = (0, utils_1.newid)();
+        expect(() => schema.parse({ recordId: validId, label: 'hello' })).not.toThrow();
+        expect(() => schema.parse({ recordId: '', label: 'hello' })).toThrow();
+    });
 });

package/dist/data/packages.d.ts

@@ -3,10 +3,10 @@ import type { DataContext } from "../context/data-context";
 import type { ISaveOptions } from "./orm/data-query";
 import { Table } from "./orm/table";
 declare const schema: z.ZodObject<{
-    packageId: z.ZodString;
+    packageId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
     description: z.ZodString;
-    createdBy: z.ZodString;
+    createdBy: z.ZodEffects<z.ZodString, string, string>;
     localPath: z.ZodString;
     disabled: z.ZodOptional<z.ZodBoolean>;
     remoteRepo: z.ZodOptional<z.ZodString>;
@@ -26,11 +26,11 @@ declare const schema: z.ZodObject<{
         navigationPath: string;
         displayName?: string | undefined;
     }>, "many">>;
-    packageBundleFileId: z.ZodString;
+    packageBundleFileId: z.ZodEffects<z.ZodString, string, string>;
     packageBundleFileHash: z.ZodString;
-    routesBundleFileId: z.ZodOptional<z.ZodString>;
+    routesBundleFileId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     routesBundleFileHash: z.ZodOptional<z.ZodString>;
-    uiBundleFileId: z.ZodOptional<z.ZodString>;
+    uiBundleFileId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     uiBundleFileHash: z.ZodOptional<z.ZodString>;
     signature: z.ZodString;
 }, "strip", z.ZodTypeAny, {

package/dist/data/packages.js

@@ -39,6 +39,7 @@ exports.Packages = Packages;
 const zod_1 = require("zod");
 const context_1 = require("../context");
 const app_nav_1 = require("../types/app-nav");
+const zod_types_1 = require("../types/zod-types");
 const decorators_1 = require("./orm/decorators");
 const table_1 = require("./orm/table");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
@@ -46,19 +47,19 @@ const types_1 = require("./orm/types");
 const package_permissions_1 = require("./package-permissions");
 const persistent_vars_1 = require("./persistent-vars");
 const schema = zod_1.z.object({
-    packageId: zod_1.z.string(),
+    packageId: zod_types_1.zodPeerId,
     name: zod_1.z.string(),
     description: zod_1.z.string(),
-    createdBy: zod_1.z.string().describe('The user who created the package'),
+    createdBy: zod_types_1.zodPeerId.describe('The user who created the package'),
     localPath: zod_1.z.string().describe('The local path where the package is stored'),
     disabled: zod_1.z.boolean().optional().describe("Whether the package's components should be loaded and included in the app runtime"),
     remoteRepo: zod_1.z.string().optional().describe('The remote repository where the package is stored'),
     appNavs: app_nav_1.appNavSchema.array().optional().describe('The app navigation items that this package provides'),
-    packageBundleFileId: zod_1.z.string().describe('File ID of the package bundle (required)'),
+    packageBundleFileId: zod_types_1.zodPeerId.describe('File ID of the package bundle (required)'),
     packageBundleFileHash: zod_1.z.string().describe('Hash of the package bundle file (required)'),
-    routesBundleFileId: zod_1.z.string().optional().describe('File ID of the routes bundle (optional)'),
+    routesBundleFileId: zod_types_1.zodPeerId.optional().describe('File ID of the routes bundle (optional)'),
     routesBundleFileHash: zod_1.z.string().optional().describe('Hash of the routes bundle (optional)'),
-    uiBundleFileId: zod_1.z.string().optional().describe('File ID of the UI bundle (optional)'),
+    uiBundleFileId: zod_types_1.zodPeerId.optional().describe('File ID of the UI bundle (optional)'),
     uiBundleFileHash: zod_1.z.string().optional().describe('Hash of the UI bundle (optional)'),
     signature: zod_1.z.string().describe('The signed hash of this data excluding the signature itself'),
 });

package/dist/data/peer-events/peer-event-handlers.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import type { DataContext } from "../../context/data-context";
 export declare const peerEventHandlerSchema: z.ZodObject<{
-    peerEventHandlerId: z.ZodString;
-    peerEventTypeId: z.ZodString;
-    handlerWorkflowId: z.ZodString;
+    peerEventHandlerId: z.ZodEffects<z.ZodString, string, string>;
+    peerEventTypeId: z.ZodEffects<z.ZodString, string, string>;
+    handlerWorkflowId: z.ZodEffects<z.ZodString, string, string>;
 }, "strip", z.ZodTypeAny, {
     peerEventTypeId: string;
     peerEventHandlerId: string;

package/dist/data/peer-events/peer-event-handlers.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.peerEventHandlerSchema = void 0;
 exports.PeerEventHandlers = PeerEventHandlers;
 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.peerEventHandlerSchema = zod_1.z.object({
-    peerEventHandlerId: zod_1.z.string(),
-    peerEventTypeId: zod_1.z.string().describe('The event type that will be handled'),
-    handlerWorkflowId: zod_1.z.string().describe('The workflow that will be triggered when this event occurs'),
+    peerEventHandlerId: zod_types_1.zodPeerId,
+    peerEventTypeId: zod_types_1.zodPeerId.describe('The event type that will be handled'),
+    handlerWorkflowId: zod_types_1.zodPeerId.describe('The workflow that will be triggered when this event occurs'),
 });
 const metaData = {
     name: 'PeerEventHandlers',

package/dist/data/peer-events/peer-event-types.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { DataContext } from "../../context/data-context";
 export declare const peerEventTypeSchema: z.ZodObject<{
-    peerEventTypeId: z.ZodString;
+    peerEventTypeId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
     description: z.ZodString;
     createdAt: z.ZodDefault<z.ZodDate>;

package/dist/data/peer-events/peer-event-types.js

@@ -7,8 +7,9 @@ const user_context_singleton_1 = require("../../context/user-context-singleton")
 const table_definitions_system_1 = require("../orm/table-definitions.system");
 const zod_1 = require("zod");
 const tools_1 = require("../tools");
+const zod_types_1 = require("../../types/zod-types");
 exports.peerEventTypeSchema = zod_1.z.object({
-    peerEventTypeId: zod_1.z.string(),
+    peerEventTypeId: zod_types_1.zodPeerId,
     name: zod_1.z.string().describe('The name of the event'),
     description: zod_1.z.string().describe('The description of the event type and what it represents'),
     createdAt: zod_1.z.date().default(() => new Date()).describe('The date the event type was created'),

package/dist/data/persistent-vars.d.ts

@@ -12,7 +12,7 @@ import { ISaveOptions } from "./orm";
 import { Table } from "./orm/table";
 import { ITableMetaData } from "./orm/types";
 declare const schema: z.ZodObject<{
-    persistentVarId: z.ZodString;
+    persistentVarId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
     scope: z.ZodEnum<["device", "user", "group", "groupDevice", "groupUser"]>;
     value: z.ZodObject<{

package/dist/data/persistent-vars.js

@@ -19,12 +19,13 @@ const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
 const observable_1 = require("../observable");
 const rpc_types_1 = require("../rpc-types");
+const zod_types_1 = require("../types/zod-types");
 const utils_1 = require("../utils");
 const table_1 = require("./orm/table");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
 const schema = zod_1.z.object({
-    persistentVarId: zod_1.z.string(),
+    persistentVarId: zod_types_1.zodPeerId,
     name: zod_1.z.string(),
     scope: zod_1.z.enum(['device', 'user', 'group', 'groupDevice', 'groupUser']),
     value: zod_1.z.object({

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { DataContext } from '../context/data-context';
+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>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    tableId: string;
+    metaData: {} & {
+        [k: string]: any;
+    };
+    versionNumber: number;
+}, {
+    name: string;
+    tableId: string;
+    metaData: {} & {
+        [k: string]: any;
+    };
+    versionNumber?: number | undefined;
+}>;
+export type ITableDefinitionRecord = z.infer<typeof tableDefinitionRecordSchema>;
+export declare function TableDefinitions(dataContext?: DataContext): import("./orm").Table<{
+    name: string;
+    tableId: string;
+    metaData: {} & {
+        [k: string]: any;
+    };
+    versionNumber: number;
+}>;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableDefinitionRecordSchema = void 0;
+exports.TableDefinitions = TableDefinitions;
+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.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'),
+    metaData: zod_types_1.zodAnyObject.describe('Full ITableMetaData object serialized as JSON'),
+    versionNumber: zod_1.z.number().default(0).describe('Version number set by the developer in the table definition; higher value wins during sync'),
+});
+const metaData = {
+    name: 'TableDefinitions',
+    description: 'Stores table schemas as tracked data so peers can learn about table definitions without needing the full package installed',
+    primaryKeyName: 'tableId',
+    fields: (0, types_1.schemaToFields)(exports.tableDefinitionRecordSchema),
+    indexes: [
+        { fields: ['name'] },
+    ],
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.tableDefinitionRecordSchema);
+function TableDefinitions(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.tableDefinitionRecordSchema);
+}

package/dist/data/tool-tests.d.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
 export declare const toolTestSchema: z.ZodObject<{
-    toolTestId: z.ZodString;
-    toolId: z.ZodString;
+    toolTestId: z.ZodEffects<z.ZodString, string, string>;
+    toolId: z.ZodEffects<z.ZodString, string, string>;
     description: z.ZodString;
     code: z.ZodDefault<z.ZodString>;
     input: z.ZodAny;

package/dist/data/tool-tests.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.toolTestSchema = void 0;
 exports.ToolTests = ToolTests;
 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.toolTestSchema = zod_1.z.object({
-    toolTestId: zod_1.z.string(),
-    toolId: zod_1.z.string(),
+    toolTestId: zod_types_1.zodPeerId,
+    toolId: zod_types_1.zodPeerId,
     description: zod_1.z.string(),
     code: zod_1.z.string().default(''),
     input: zod_1.z.any(),

package/dist/data/tools.d.ts

@@ -58,7 +58,7 @@ export declare const ioSchema: z.ZodObject<{
 }>;
 export type IOSchema = z.infer<typeof ioSchema>;
 export declare const toolSchema: z.ZodObject<{
-    toolId: z.ZodString;
+    toolId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
     usageDescription: z.ZodString;
     detailedDescription: z.ZodOptional<z.ZodString>;

package/dist/data/tools.js

@@ -4,6 +4,7 @@ exports.toolSchema = exports.ioSchema = exports.IOSchemaType = void 0;
 exports.Tools = Tools;
 const zod_1 = require("zod");
 const field_type_1 = require("../types/field-type");
+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");
@@ -19,7 +20,7 @@ exports.ioSchema = zod_1.z.object({
     fields: field_type_1.fieldSchema.array().default([]),
 });
 exports.toolSchema = zod_1.z.object({
-    toolId: zod_1.z.string(),
+    toolId: zod_types_1.zodPeerId,
     name: zod_1.z.string().describe('The name of the tool'),
     usageDescription: zod_1.z.string().describe('A description of the what the tool does and how to use it.  This is used by the AI to reason about the tool at runtime and in the middle of performing tasks.'),
     detailedDescription: zod_1.z.string().optional().describe('A full description of the tool which may include examples, references, screenshots, etc.  This is intended for humans and AI to decide if this is a tool they want to include in their toolbox while preparing to work on tasks.'),

package/dist/data/user-trust-levels.d.ts

@@ -9,7 +9,7 @@ import { TrustLevel } from "../device/socket.type";
  * Each context can maintain its own trust assessment of other users.
  */
 export declare const userTrustLevelSchema: z.ZodObject<{
-    userId: z.ZodString;
+    userId: z.ZodEffects<z.ZodString, string, string>;
     trustLevel: z.ZodNativeEnum<typeof TrustLevel>;
     assignedAt: z.ZodOptional<z.ZodDate>;
     notes: z.ZodOptional<z.ZodString>;

package/dist/data/user-trust-levels.js

@@ -7,6 +7,7 @@ exports.setUserTrustLevel = setUserTrustLevel;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
 const socket_type_1 = require("../device/socket.type");
+const zod_types_1 = require("../types/zod-types");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
 /**
@@ -17,7 +18,7 @@ const types_1 = require("./orm/types");
  * Each context can maintain its own trust assessment of other users.
  */
 exports.userTrustLevelSchema = zod_1.z.object({
-    userId: zod_1.z.string().describe('The user being assigned a trust level'),
+    userId: zod_types_1.zodPeerId.describe('The user being assigned a trust level'),
     trustLevel: zod_1.z.nativeEnum(socket_type_1.TrustLevel).describe('The trust level assigned to this user in this context'),
     assignedAt: zod_1.z.date().optional().describe('When the trust level was assigned'),
     notes: zod_1.z.string().optional().describe('Optional notes about why this trust level was assigned'),

package/dist/data/users.d.ts

@@ -3,7 +3,7 @@ import type { DataContext } from "../context/data-context";
 import type { ISaveOptions } from "./orm/data-query";
 import { Table } from "./orm/table";
 export declare const userSchema: z.ZodObject<{
-    userId: z.ZodString;
+    userId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
     publicKey: z.ZodString;
     publicBoxKey: z.ZodString;
@@ -34,5 +34,4 @@ export declare class UsersTable extends Table<IUser> {
     update(..._args: Parameters<Table<IUser>['update']>): never;
 }
 export declare function Users(dataContext?: DataContext): UsersTable;
-export declare const myUserId: import("./persistent-vars").PersistentVar<string>;
 export declare function getMe(): Promise<IUser>;

package/dist/data/users.js

@@ -34,19 +34,19 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     done = true;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.myUserId = exports.UsersTable = exports.userSchema = void 0;
+exports.UsersTable = exports.userSchema = void 0;
 exports.Users = Users;
 exports.getMe = getMe;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
+const zod_types_1 = require("../types/zod-types");
 const decorators_1 = require("./orm/decorators");
 const table_1 = require("./orm/table");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
-const persistent_vars_1 = require("./persistent-vars");
 const user_permissions_1 = require("./user-permissions");
 exports.userSchema = zod_1.z.object({
-    userId: zod_1.z.string(),
+    userId: zod_types_1.zodPeerId,
     name: zod_1.z.string(),
     publicKey: zod_1.z.string().describe('The public key the user uses to sign messages'),
     publicBoxKey: zod_1.z.string().describe('The public key to use to encrypt data that only this user can decrypt'),
@@ -122,7 +122,6 @@ exports.UsersTable = UsersTable;
 function Users(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.userSchema, UsersTable);
 }
-exports.myUserId = (0, persistent_vars_1.deviceVar)('myUserId', { defaultValue: '' });
 // let me: IUser | undefined = undefined;
 async function getMe() {
     const userContext = await (0, user_context_singleton_1.getUserContext)();

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

@@ -10,8 +10,8 @@ export declare const workflowLogSchema: z.ZodObject<{
     instruction: z.ZodOptional<z.ZodObject<{
         markdown: z.ZodOptional<z.ZodString>;
         onError: z.ZodOptional<z.ZodString>;
-        directCallToolId: z.ZodOptional<z.ZodString>;
-        subWorkflowId: z.ZodOptional<z.ZodString>;
+        directCallToolId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        subWorkflowId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     }, "strip", z.ZodTypeAny, {
         markdown?: string | undefined;
         onError?: string | undefined;

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

@@ -11,8 +11,8 @@ export declare const workflowRunSchema: z.ZodObject<{
     instructions: z.ZodDefault<z.ZodArray<z.ZodObject<{
         markdown: z.ZodOptional<z.ZodString>;
         onError: z.ZodOptional<z.ZodString>;
-        directCallToolId: z.ZodOptional<z.ZodString>;
-        subWorkflowId: z.ZodOptional<z.ZodString>;
+        directCallToolId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        subWorkflowId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     }, "strip", z.ZodTypeAny, {
         markdown?: string | undefined;
         onError?: string | undefined;

package/dist/keys.js

@@ -63,6 +63,9 @@ function encodeBase64(data) {
     return str.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
 }
 function decodeBase64(data) {
+    if (typeof data !== 'string') {
+        throw new TypeError(`decodeBase64 expected a string but received ${typeof data}`);
+    }
     data = data.replace(/-/g, '+').replace(/_/g, '/');
     while (data.length % 4 !== 0) {
         data += '=';
@@ -211,9 +214,12 @@ function addSignatureToObject(obj, secretKey) {
  * Will throw if the signature is invalid
  */
 function verifyObjectSignature(objectWithSignature) {
+    if (!objectWithSignature.signature) {
+        throw new Error('Object has no signature to verify');
+    }
     const objWithoutSignature = { ...objectWithSignature };
     delete objWithoutSignature.signature;
-    const [objPublicKey, objSignature] = objectWithSignature.signature?.split(':') || [];
+    const [objPublicKey, objSignature] = objectWithSignature.signature.split(':');
     const signedObject = {
         contents: objWithoutSignature,
         signature: objSignature,

package/dist/types/workflow.d.ts

@@ -2,8 +2,8 @@ import { z } from "zod";
 export declare const workflowInstructionSchema: z.ZodObject<{
     markdown: z.ZodOptional<z.ZodString>;
     onError: z.ZodOptional<z.ZodString>;
-    directCallToolId: z.ZodOptional<z.ZodString>;
-    subWorkflowId: z.ZodOptional<z.ZodString>;
+    directCallToolId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    subWorkflowId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strip", z.ZodTypeAny, {
     markdown?: string | undefined;
     onError?: string | undefined;
@@ -17,15 +17,15 @@ export declare const workflowInstructionSchema: z.ZodObject<{
 }>;
 export type IWorkflowInstruction = z.infer<typeof workflowInstructionSchema>;
 export declare const workflowSchema: z.ZodObject<{
-    workflowId: z.ZodString;
+    workflowId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
     description: z.ZodString;
-    defaultAssistantId: z.ZodString;
+    defaultAssistantId: z.ZodEffects<z.ZodString, string, string>;
     instructions: z.ZodDefault<z.ZodArray<z.ZodObject<{
         markdown: z.ZodOptional<z.ZodString>;
         onError: z.ZodOptional<z.ZodString>;
-        directCallToolId: z.ZodOptional<z.ZodString>;
-        subWorkflowId: z.ZodOptional<z.ZodString>;
+        directCallToolId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        subWorkflowId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     }, "strip", z.ZodTypeAny, {
         markdown?: string | undefined;
         onError?: string | undefined;
@@ -37,7 +37,7 @@ export declare const workflowSchema: z.ZodObject<{
         directCallToolId?: string | undefined;
         subWorkflowId?: string | undefined;
     }>, "many">>;
-    createdBy: z.ZodString;
+    createdBy: z.ZodEffects<z.ZodString, string, string>;
     createdAt: z.ZodDefault<z.ZodDate>;
     updatedAt: z.ZodDefault<z.ZodDate>;
 }, "strip", z.ZodTypeAny, {

package/dist/types/workflow.js

@@ -2,23 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.workflowSchema = exports.workflowInstructionSchema = void 0;
 const zod_1 = require("zod");
+const zod_types_1 = require("./zod-types");
 exports.workflowInstructionSchema = zod_1.z.object({
     markdown: zod_1.z.string().optional().describe('The instruction in markdown format'),
     onError: zod_1.z.string().optional().describe('The instruction to run if there is an error while running this instruction'),
-    directCallToolId: zod_1.z.string().optional().describe('The tool to call directly with the tool id'),
-    subWorkflowId: zod_1.z.string().optional().describe('The sub workflow to run with the workflow id'),
+    directCallToolId: zod_types_1.zodPeerId.optional().describe('The tool to call directly with the tool id'),
+    subWorkflowId: zod_types_1.zodPeerId.optional().describe('The sub workflow to run with the workflow id'),
 });
 exports.workflowSchema = zod_1.z.object({
-    workflowId: zod_1.z.string(),
+    workflowId: zod_types_1.zodPeerId,
     name: zod_1.z.string().describe('The name of the workflow'),
     description: zod_1.z.string().describe('A detailed description of the workflow that can be used to help users and assistants understand what the workflow does'),
-    defaultAssistantId: zod_1.z.string().describe('The default assistant to handle instructions when the workflow is run'),
+    defaultAssistantId: zod_types_1.zodPeerId.describe('The default assistant to handle instructions when the workflow is run'),
     instructions: exports.workflowInstructionSchema
         .array().describe([
         'The instructions for the workflow.  This should be written in markdown and can include special links to other workflows, tools, etc. via mentions',
         'The instructions should be broken down into discrete steps and should be as clear as possible.',
     ].join(' ')).default([]),
-    createdBy: zod_1.z.string().describe('The user who created the workflow'),
+    createdBy: zod_types_1.zodPeerId.describe('The user who created the workflow'),
     createdAt: zod_1.z.date().default(() => new Date()).describe('The date the workflow was created'),
     updatedAt: zod_1.z.date().default(() => new Date()).describe('The date the workflow was last updated'),
 });

package/dist/types/zod-types.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zodPeerId = exports.zodAnyObjectOrArray = exports.zodAnyObject = void 0;
 const zod_1 = require("zod");
+const field_type_1 = require("./field-type");
 const utils_1 = require("../utils");
 exports.zodAnyObject = zod_1.z.object({}).catchall(zod_1.z.any());
 exports.zodAnyObjectOrArray = zod_1.z.union([exports.zodAnyObject, zod_1.z.array(zod_1.z.any())]);
@@ -10,3 +11,4 @@ exports.zodPeerId = zod_1.z.string().refine(value => {
 }, {
     message: "Invalid peer id, it must be a 25 character alphanumeric string",
 });
+exports.zodPeerId._def._fieldType = field_type_1.FieldType.id;