@peers-app/peers-sdk 0.1.4 → 0.1.6

package/dist/context/data-context.js

@@ -24,7 +24,7 @@ class DataContext {
         this.tableContainer = new orm_1.TableContainer(tableFactory, groupId);
     }
     get dataContextId() {
-        return this.groupId || this.userContext.userId();
+        return this.groupId || this.userContext.userId;
     }
     /**
      * Call this to indicate that this should be the current data context to be used unless otherwise specified

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

@@ -5,7 +5,7 @@ export declare function getUserContext(): Promise<UserContext>;
 export declare function setUserContext(userContext: UserContext): void;
 export declare function getDefaultDataContext(): Promise<DataContext>;
 export declare function getTableContainer(dataContext?: DataContext | undefined): import("../data/orm").TableContainer;
-export declare function setDefaultClientUserContext(): void;
+export declare function setDefaultClientUserContext(userId: string): void;
 export declare function getAllTables(): {
     [tableName: string]: Table<any>;
 };

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

@@ -53,11 +53,11 @@ function getTableContainer(dataContext) {
     }
     return dataContext.tableContainer;
 }
-function setDefaultClientUserContext() {
+function setDefaultClientUserContext(userId) {
     const clientProxyDataSourceFactory = (metaData, schema, groupId) => {
         return new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, groupId ?? '');
     };
-    const userContext = new user_context_1.UserContext(clientProxyDataSourceFactory);
+    const userContext = new user_context_1.UserContext(userId, clientProxyDataSourceFactory);
     (async () => {
         const { GroupsTable } = await Promise.resolve().then(() => require("../data/groups"));
         const { GroupMembersTable } = await Promise.resolve().then(() => require("../data/group-members"));
@@ -77,45 +77,47 @@ function getAllTables() {
     }
     return tableMap;
 }
-async function getTable(dataContextId, tableName) {
-    const userContext = await getUserContext();
-    const table = userContext
-        .getDataContext(dataContextId || userContext.userId())
-        .tableContainer
-        .getTable(tableName);
-    return table;
+if (!rpc_types_1.isClient) {
+    async function getTable(dataContextId, tableName) {
+        const userContext = await getUserContext();
+        const table = userContext
+            .getDataContext(dataContextId || userContext.userId)
+            .tableContainer
+            .getTable(tableName);
+        return table;
+    }
+    // TODO: add check that client has permission to do the operation to the table
+    rpc_types_1.rpcServerCalls.tableGet = async (dataContextId, tableName, id) => {
+        const table = await getTable(dataContextId, tableName);
+        return table.get(id);
+    };
+    rpc_types_1.rpcServerCalls.tableList = async (dataContextId, tableName, filter, opts) => {
+        const table = await getTable(dataContextId, tableName);
+        return table.list(filter, opts);
+    };
+    rpc_types_1.rpcServerCalls.tableCount = async (dataContextId, tableName, filter) => {
+        const table = await getTable(dataContextId, tableName);
+        return table.count(filter);
+    };
+    rpc_types_1.rpcServerCalls.tableSave = async (dataContextId, tableName, data, opts) => {
+        const table = await getTable(dataContextId, tableName);
+        return table.save(data, opts);
+    };
+    rpc_types_1.rpcServerCalls.tableInsert = async (dataContextId, tableName, data) => {
+        const table = await getTable(dataContextId, tableName);
+        return table.insert(data);
+    };
+    rpc_types_1.rpcServerCalls.tableUpdate = async (dataContextId, tableName, data) => {
+        const table = await getTable(dataContextId, tableName);
+        return table.update(data);
+    };
+    rpc_types_1.rpcServerCalls.tableDelete = async (dataContextId, tableName, idOrRecord) => {
+        const table = await getTable(dataContextId, tableName);
+        return table.delete(idOrRecord);
+    };
+    rpc_types_1.rpcServerCalls.tableMethodCall = async (dataContextId, tableName, methodName, ...args) => {
+        const table = await getTable(dataContextId, tableName);
+        // @ts-ignore
+        return table[methodName](...args);
+    };
 }
-// TODO: add check that client has permission to do the operation to the table
-rpc_types_1.rpcServerCalls.tableGet = async (dataContextId, tableName, id) => {
-    const table = await getTable(dataContextId, tableName);
-    return table.get(id);
-};
-rpc_types_1.rpcServerCalls.tableList = async (dataContextId, tableName, filter, opts) => {
-    const table = await getTable(dataContextId, tableName);
-    return table.list(filter, opts);
-};
-rpc_types_1.rpcServerCalls.tableCount = async (dataContextId, tableName, filter) => {
-    const table = await getTable(dataContextId, tableName);
-    return table.count(filter);
-};
-rpc_types_1.rpcServerCalls.tableSave = async (dataContextId, tableName, data, opts) => {
-    const table = await getTable(dataContextId, tableName);
-    return table.save(data, opts);
-};
-rpc_types_1.rpcServerCalls.tableInsert = async (dataContextId, tableName, data) => {
-    const table = await getTable(dataContextId, tableName);
-    return table.insert(data);
-};
-rpc_types_1.rpcServerCalls.tableUpdate = async (dataContextId, tableName, data) => {
-    const table = await getTable(dataContextId, tableName);
-    return table.update(data);
-};
-rpc_types_1.rpcServerCalls.tableDelete = async (dataContextId, tableName, idOrRecord) => {
-    const table = await getTable(dataContextId, tableName);
-    return table.delete(idOrRecord);
-};
-rpc_types_1.rpcServerCalls.tableMethodCall = async (dataContextId, tableName, methodName, ...args) => {
-    const table = await getTable(dataContextId, tableName);
-    // @ts-ignore
-    return table[methodName](...args);
-};

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

@@ -5,8 +5,8 @@ import { TrustLevel } from "../device/socket.type";
 import { IPublicPrivateKeys } from "../keys";
 import { Observable } from "../observable";
 export declare class UserContext {
+    readonly userId: string;
     readonly dataSourceFactory: DataSourceFactory;
-    readonly userId: Observable<string>;
     readonly deviceId: Observable<string>;
     readonly currentlyActiveGroupId: Observable<string | undefined>;
     readonly packagesRootDir: Observable<string>;
@@ -19,7 +19,7 @@ export declare class UserContext {
     readonly groupDataContexts: Map<string, DataContext>;
     readonly defaultDataContext: Observable<DataContext>;
     readonly loadingPromise: Promise<UserContext>;
-    constructor(dataSourceFactory: DataSourceFactory);
+    constructor(userId: string, dataSourceFactory: DataSourceFactory);
     private init;
     /**
      * We want to load all packages as part of user context initialization
@@ -37,12 +37,12 @@ export declare class UserContext {
     getMe(): Promise<{
         name: string;
         publicKey: string;
-        userId: string;
         publicBoxKey: string;
+        userId: string;
         signature?: string | undefined;
         trustLevel?: TrustLevel | undefined;
     } | undefined>;
-    syncUserAndGroupObjects(keys: IPublicPrivateKeys, me?: IUser): Promise<void>;
+    syncUserAndGroupObjects(userId: string, keys: IPublicPrivateKeys, me?: IUser): Promise<void>;
     subscribeToDataChangedAcrossAllGroups<T extends {
         [key: string]: any;
     }>(table: Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;

package/dist/context/user-context.js

@@ -10,8 +10,9 @@ const keys_1 = require("../keys");
 const observable_1 = require("../observable");
 const utils_1 = require("../utils");
 class UserContext {
+    userId;
     dataSourceFactory;
-    userId = (0, observable_1.observable)('');
+    // public readonly userId: Observable<string> = observable<string>('');
     deviceId = (0, observable_1.observable)('');
     currentlyActiveGroupId = (0, observable_1.observable)();
     packagesRootDir = (0, observable_1.observable)('');
@@ -22,7 +23,8 @@ class UserContext {
     groupDataContexts = new Map();
     defaultDataContext = (0, observable_1.observable)();
     loadingPromise;
-    constructor(dataSourceFactory) {
+    constructor(userId, dataSourceFactory) {
+        this.userId = userId;
         this.dataSourceFactory = dataSourceFactory;
         this.userDataContext = new data_context_1.DataContext(this);
         this.defaultDataContext(this.userDataContext);
@@ -72,7 +74,7 @@ class UserContext {
         }
         // ensure when currentlyActiveGroupId changes, currentlyActiveGroup is updated and vice versa
         this.currentlyActiveGroupId.subscribe(async (groupId) => {
-            const dataContext = this.getDataContext(groupId || this.userId());
+            const dataContext = this.getDataContext(groupId || this.userId);
             this.defaultDataContext(dataContext);
         });
         this.defaultDataContext.subscribe((group) => {
@@ -85,11 +87,11 @@ class UserContext {
         });
     }
     getDataContext(groupId) {
-        if (groupId === this.userId()) {
+        if (!groupId || groupId === this.userId) {
             return this.userDataContext;
         }
         if (!(0, utils_1.isid)(groupId)) {
-            throw new Error(`dataContextId is not a valid id: ${groupId}`);
+            throw new Error(`groupId is not a valid id: ${groupId}`);
         }
         if (!this.groupDataContexts.has(groupId)) {
             if (!this.groupIds().includes(groupId)) {
@@ -112,9 +114,9 @@ class UserContext {
             acc[curr.name] = curr.value?.value;
             return acc;
         }, {});
-        const userIdPVar = (0, data_1.deviceVar)('myUserId', { dbValue: varDbValues['myUserId'], userContext: this });
-        this.userId(userIdPVar());
-        (0, observable_1.linkObservables)(userIdPVar, this.userId);
+        // const userIdPVar = deviceVar<string>('myUserId', { dbValue: varDbValues['myUserId'], userContext: this });
+        // this.userId(userIdPVar());
+        // linkObservables(userIdPVar, this.userId);
         const deviceIdPVar = (0, data_1.deviceVar)('thisDeviceId', { dbValue: varDbValues['thisDeviceId'], userContext: this });
         this.deviceId(deviceIdPVar());
         (0, observable_1.linkObservables)(deviceIdPVar, this.deviceId);
@@ -131,15 +133,15 @@ class UserContext {
         this.packageLocalPathsResolved(packageLocalPathsResolvedPVar());
         (0, observable_1.linkObservables)(packageLocalPathsResolvedPVar, this.packageLocalPathsResolved);
         if (typeof process !== 'undefined' && process.env) {
-            if (process.env.USER_ID) {
-                this.userId(process.env.USER_ID);
-            }
+            // if (process.env.USER_ID) {
+            //   this.userId(process.env.USER_ID);
+            // }
             if (process.env.DEVICE_ID) {
                 this.deviceId(process.env.DEVICE_ID);
             }
         }
         await Promise.all([
-            userIdPVar.loadingPromise,
+            // userIdPVar.loadingPromise,
             deviceIdPVar.loadingPromise,
             packagesRootDirPVar.loadingPromise,
             reloadPackagesOnPageRefreshPVar.loadingPromise,
@@ -147,15 +149,23 @@ class UserContext {
         ]);
     }
     async getMe() {
-        let dbMe = await (0, data_1.Users)(this.userDataContext).get(this.userId(), { useCache: true });
+        let dbMe = await (0, data_1.Users)(this.userDataContext).get(this.userId, { useCache: true });
         return dbMe;
     }
-    async syncUserAndGroupObjects(keys, me) {
+    async syncUserAndGroupObjects(userId, keys, me) {
         // update my user object for all contexts
         const userContext = this;
         me ??= await this.getMe();
         if (!me) {
-            throw new Error('My user object was not passed in and was not found in my personal db');
+            // throw new Error('My user object was not passed in and was not found in my personal db')
+            console.warn(`My user object was not in db, creating now`);
+            me = {
+                userId,
+                name: 'Unnamed_1',
+                publicKey: '',
+                publicBoxKey: '',
+                trustLevel: socket_type_1.TrustLevel.Self,
+            };
         }
         me.publicKey = keys.publicKey;
         me.publicBoxKey = keys.publicBoxKey;
@@ -190,7 +200,7 @@ class UserContext {
     subscribeToDataChangedAcrossAllGroups(table, handler) {
         const tableEventPrefix = `${table.tableName}_DataChanged_`;
         const subscription = (0, events_1.subscribe)(evt => evt.name.startsWith(tableEventPrefix), async (evt) => {
-            const dataContextId = evt.name.endsWith('_') ? this.userId() : evt.name.split('_').pop();
+            const dataContextId = evt.name.endsWith('_') ? this.userId : evt.name.split('_').pop();
             const dataContext = this.getDataContext(dataContextId);
             handler({
                 name: evt.name,

package/dist/data/assistants.d.ts

@@ -39,7 +39,7 @@ export declare const assistantSchema: z.ZodObject<{
     toolInclusionStrategy?: ToolInclusionStrategy | undefined;
 }>;
 export type IAssistant = z.infer<typeof assistantSchema>;
-export declare function Assistants(dataContext?: DataContext): import("./orm").Table<{
+export declare function Assistants(dataContext?: DataContext): import("..").Table<{
     name: string;
     createdAt: Date;
     assistantId: string;

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

@@ -10,22 +10,22 @@ declare const insertChange: z.ZodObject<{
     recordId: z.ZodString;
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
 }, "strip", z.ZodTypeAny, {
+    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
 }, {
+    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -40,20 +40,20 @@ declare const deleteChange: z.ZodObject<{
     recordId: z.ZodString;
     oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
 }, "strip", z.ZodTypeAny, {
+    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }, {
+    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
 }>;
 export type IChangeDelete = z.infer<typeof deleteChange>;
@@ -67,23 +67,23 @@ declare const updateChange: z.ZodObject<{
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
     jsonDiff: z.ZodArray<z.ZodAny, "many">;
 }, "strip", z.ZodTypeAny, {
+    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
     jsonDiff: any[];
 }, {
+    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -99,22 +99,22 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     recordId: z.ZodString;
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
 }, "strip", z.ZodTypeAny, {
+    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
 }, {
+    recordId: string;
     changeId: string;
     changeType: "insert" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -127,20 +127,20 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     recordId: z.ZodString;
     oldRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
 }, "strip", z.ZodTypeAny, {
+    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }, {
+    recordId: string;
     changeId: string;
     changeType: "delete";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
 }>, z.ZodObject<{
     changeId: z.ZodEffects<z.ZodString, string, string>;
@@ -152,23 +152,23 @@ declare const changeSchema: z.ZodUnion<[z.ZodObject<{
     newRecord: z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>;
     jsonDiff: z.ZodArray<z.ZodAny, "many">;
 }, "strip", z.ZodTypeAny, {
+    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
     jsonDiff: any[];
 }, {
+    recordId: string;
     changeId: string;
     changeType: "update";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord: {} & {
         [k: string]: any;
     };
@@ -186,25 +186,25 @@ export declare const changeTrackingSchema: z.ZodObject<{
     newRecord: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
     jsonDiff: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
 }, "strip", z.ZodTypeAny, {
+    recordId: string;
     changeId: string;
     changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
-    oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
     jsonDiff?: any[] | undefined;
+    oldRecord?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
 }, {
+    recordId: string;
     changeId: string;
     changeType: "update" | "insert" | "delete" | "snapshot" | "restore";
     timestamp: number;
     timestampApplied: number;
     tableName: string;
-    recordId: string;
     newRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
-    oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
     jsonDiff?: any[] | undefined;
+    oldRecord?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
 }>;
 export type IChangeAny = z.infer<typeof changeTrackingSchema>;
 export declare class ChangeTrackingTable extends SQLDataSource<IChange> {

package/dist/data/channels.d.ts

@@ -20,7 +20,7 @@ export declare const channelSchema: z.ZodObject<{
     owningGroupId: string;
 }>;
 export type IChannel = z.infer<typeof channelSchema>;
-export declare function Channels(dataContext?: DataContext): import("./orm").Table<{
+export declare function Channels(dataContext?: DataContext): import("..").Table<{
     name: string;
     description: string;
     createdAt: Date;

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

@@ -7,13 +7,13 @@ export declare const dataLockSchema: z.ZodObject<{
     lockedUntil: z.ZodNumber;
     acknowledged: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    recordId: string;
     dataLockId: string;
+    recordId: string;
     lockedUntil: number;
     acknowledged?: number | undefined;
 }, {
-    recordId: string;
     dataLockId: string;
+    recordId: string;
     lockedUntil: number;
     acknowledged?: number | undefined;
 }>;

package/dist/data/devices.d.ts

@@ -38,7 +38,7 @@ export interface IDeviceHandshake extends IDeviceInfo {
     serverAddress: string;
     timestamp: number;
 }
-export declare function Devices(dataContext?: DataContext): import("./orm").Table<{
+export declare function Devices(dataContext?: DataContext): import("..").Table<{
     userId: string;
     trustLevel: TrustLevel;
     deviceId: string;

package/dist/data/embeddings.d.ts

@@ -34,7 +34,7 @@ export declare const embeddingSchema: z.ZodObject<{
     embeddingType: string;
 }>;
 export type IEmbedding = z.infer<typeof embeddingSchema>;
-export declare function Embeddings(dataContext?: DataContext): import("./orm").Table<{
+export declare function Embeddings(dataContext?: DataContext): import("..").Table<{
     metadata: {
         fkId?: string | undefined;
     } & {

package/dist/data/group-members.d.ts

@@ -13,16 +13,16 @@ export declare const groupMemberSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     role: GroupMemberRole;
     signature: string;
-    groupMemberId: string;
     groupId: string;
     userId: string;
+    groupMemberId: string;
     deleted?: boolean | undefined;
 }, {
     role: GroupMemberRole;
     signature: string;
-    groupMemberId: string;
     groupId: string;
     userId: string;
+    groupMemberId: string;
     deleted?: boolean | undefined;
 }>;
 export type IGroupMember = z.infer<typeof groupMemberSchema>;

package/dist/data/knowledge/knowledge-frames.d.ts

@@ -23,7 +23,7 @@ declare const knowledgeFrameSchema: z.ZodObject<{
     conclusion?: string | undefined;
 }>;
 export type IKnowledgeFrame = z.infer<typeof knowledgeFrameSchema>;
-export declare function KnowledgeFrames(dataContext?: DataContext): import("../orm").Table<{
+export declare function KnowledgeFrames(dataContext?: DataContext): import("../..").Table<{
     name: string;
     body: string;
     knowledgeFrameId: string;

package/dist/data/knowledge/knowledge-links.d.ts

@@ -20,7 +20,7 @@ declare const knowledgeLinkSchema: z.ZodObject<{
     objectValueId?: string | undefined;
 }>;
 export type IKnowledgeLink = z.infer<typeof knowledgeLinkSchema>;
-export declare function KnowledgeLinks(dataContext?: DataContext): import("../orm").Table<{
+export declare function KnowledgeLinks(dataContext?: DataContext): import("../..").Table<{
     knowledgeLinkId: string;
     subjectValueId: string;
     predicateId: string;

package/dist/data/knowledge/knowledge-values.d.ts

@@ -24,7 +24,7 @@ export declare const knowledgeValueSchema: z.ZodObject<{
     lastModified?: Date | undefined;
 }>;
 export type IKnowledgeValue = z.infer<typeof knowledgeValueSchema>;
-export declare function KnowledgeValues(dataContext?: DataContext): import("../orm").Table<{
+export declare function KnowledgeValues(dataContext?: DataContext): import("../..").Table<{
     name: string;
     value: {} & {
         [k: string]: any;

package/dist/data/knowledge/peer-types.d.ts

@@ -91,7 +91,7 @@ declare const valueTypeSchema: z.ZodObject<{
     iconClass?: string | undefined;
 }>;
 export type IPeerType = z.infer<typeof valueTypeSchema>;
-export declare function PeerTypes(dataContext?: DataContext): import("../orm").Table<{
+export declare function PeerTypes(dataContext?: DataContext): import("../..").Table<{
     name: string;
     schema: {
         type: import("../tools").IOSchemaType;

package/dist/data/knowledge/predicates.d.ts

@@ -23,7 +23,7 @@ declare const predicateSchema: z.ZodObject<{
     allowedObjectValueTypes?: string[] | undefined;
 }>;
 export type IPredicate = z.infer<typeof predicateSchema>;
-export declare function Predicates(dataContext?: DataContext): import("../orm").Table<{
+export declare function Predicates(dataContext?: DataContext): import("../..").Table<{
     name: string;
     predicateId: string;
     description?: string | undefined;

package/dist/data/messages.d.ts

@@ -13,8 +13,8 @@ export declare const messageSchema: z.ZodObject<{
     vars: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    createdAt: Date;
     userId: string;
+    createdAt: Date;
     channelId: string;
     messageId: string;
     assistantId?: string | undefined;
@@ -24,8 +24,8 @@ export declare const messageSchema: z.ZodObject<{
     fileIds?: string[] | undefined;
 }, {
     message: string;
-    createdAt: Date;
     userId: string;
+    createdAt: Date;
     channelId: string;
     messageId: string;
     assistantId?: string | undefined;
@@ -35,10 +35,10 @@ export declare const messageSchema: z.ZodObject<{
     fileIds?: string[] | undefined;
 }>;
 export type IMessage = z.infer<typeof messageSchema>;
-export declare function Messages(dataContext?: DataContext): import("./orm").Table<{
+export declare function Messages(dataContext?: DataContext): import("..").Table<{
     message: string;
-    createdAt: Date;
     userId: string;
+    createdAt: Date;
     channelId: string;
     messageId: string;
     assistantId?: string | undefined;

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

@@ -14,7 +14,7 @@ export declare const peerEventHandlerSchema: z.ZodObject<{
     handlerWorkflowId: string;
 }>;
 export type IPeerEventHandler = z.infer<typeof peerEventHandlerSchema>;
-export declare function PeerEventHandlers(dataContext?: DataContext): import("../orm").Table<{
+export declare function PeerEventHandlers(dataContext?: DataContext): import("../..").Table<{
     peerEventTypeId: string;
     peerEventHandlerId: string;
     handlerWorkflowId: string;

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

@@ -97,7 +97,7 @@ export declare const peerEventTypeSchema: z.ZodObject<{
     nextScheduledTime?: number | undefined;
 }>;
 export type IPeerEventType = z.infer<typeof peerEventTypeSchema>;
-export declare function PeerEventTypes(dataContext?: DataContext): import("../orm").Table<{
+export declare function PeerEventTypes(dataContext?: DataContext): import("../..").Table<{
     name: string;
     description: string;
     schema: {

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

@@ -26,7 +26,7 @@ export declare const toolTestSchema: z.ZodObject<{
     mocks?: any;
 }>;
 export type IToolTest = z.infer<typeof toolTestSchema>;
-export declare function ToolTests(dataContext?: DataContext): import("./orm").Table<{
+export declare function ToolTests(dataContext?: DataContext): import("..").Table<{
     code: string;
     description: string;
     toolId: string;

package/dist/data/tools.d.ts

@@ -311,7 +311,7 @@ export interface IToolInstance {
     inputSchema?: z.ZodObject<any>;
     outputSchema?: z.ZodObject<any>;
 }
-export declare function Tools(dataContext?: DataContext): import("./orm").Table<{
+export declare function Tools(dataContext?: DataContext): import("..").Table<{
     code: string;
     name: string;
     toolId: string;

package/dist/data/users.d.ts

@@ -12,15 +12,15 @@ export declare const userSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     name: string;
     publicKey: string;
-    userId: string;
     publicBoxKey: string;
+    userId: string;
     signature?: string | undefined;
     trustLevel?: TrustLevel | undefined;
 }, {
     name: string;
     publicKey: string;
-    userId: string;
     publicBoxKey: string;
+    userId: string;
     signature?: string | undefined;
     trustLevel?: TrustLevel | undefined;
 }>;

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

@@ -66,7 +66,7 @@ export declare const workflowLogSchema: z.ZodObject<{
     isError?: boolean | undefined;
 }>;
 export type IWorkflowLog = z.infer<typeof workflowLogSchema>;
-export declare function WorkflowLogs(dataContext?: DataContext): import("./orm").Table<{
+export declare function WorkflowLogs(dataContext?: DataContext): import("..").Table<{
     workflowLogId: string;
     workflowRunId: string;
     contextId: string;

package/dist/data/workflows.d.ts

@@ -1,5 +1,5 @@
 import type { DataContext } from "../context/data-context";
-export declare function Workflows(dataContext?: DataContext): import("./orm").Table<{
+export declare function Workflows(dataContext?: DataContext): import("..").Table<{
     name: string;
     description: string;
     createdAt: Date;

package/dist/rpc-types.d.ts

@@ -12,12 +12,13 @@ export declare const rpcServerCalls: {
     addRemotePackage: ((remoteRepo: string) => Promise<string>);
     linkRemoteRepo: ((packageId: string) => Promise<void>);
     installOrUpdatePackage: ((packageId: string) => Promise<void>);
+    setUserIdAndSecretKey: ((userId: string, secretKey: string) => Promise<void>);
+    getUserId: () => Promise<string | undefined>;
     updateUserSettings: ((settings: {
         id: string;
         name: string;
         value: any;
     }) => Promise<void>);
-    setSecretKey: ((secretKey: string) => Promise<void>);
     encryptData: ((value: string, groupId?: string) => Promise<string>);
     tableGet: (dataContextId: string, tableName: string, id: string, opts?: {
         useCache?: boolean;

package/dist/rpc-types.js

@@ -15,8 +15,9 @@ exports.rpcServerCalls = {
     addRemotePackage: rpcStub('addRemotePackage'),
     linkRemoteRepo: rpcStub('linkRemoteRepo'),
     installOrUpdatePackage: rpcStub('installOrUpdatePackage'),
+    setUserIdAndSecretKey: rpcStub('setUserIdAndSecretKey'),
+    getUserId: rpcStub('getUserId'),
     updateUserSettings: rpcStub('updateUserSettings'),
-    setSecretKey: rpcStub('setSecretKey'),
     encryptData: rpcStub('encryptData'),
     tableGet: rpcStub('tableGet'),
     tableList: rpcStub('tableList'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"
@@ -20,10 +20,14 @@
     "./data": "./dist/data/index.js"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc",
+    "clean": "rm -rf dist",
+    "build": "yarn clean && tsc",
     "dev": "tsc -w",
     "test": "jest",
-    "deploy": "yarn build && npm version patch && npm publish && git push"
+    "release:patch": "yarn build && npm version patch && git push && git push --tags",
+    "release:minor": "yarn build && npm version minor && git push && git push --tags",
+    "release:major": "yarn build && npm version major && git push && push --tags",
+    "release": "yarn release:patch"
   },
   "dependencies": {
     "@noble/hashes": "^1.8.0",