@peers-app/peers-sdk 0.7.2 → 0.7.5

package/dist/logging/console-logs.table.js

@@ -0,0 +1,140 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogsTable = exports.consoleLogSchema = void 0;
+exports.ConsoleLogs = ConsoleLogs;
+const zod_1 = require("zod");
+const zod_types_1 = require("../types/zod-types");
+const types_1 = require("../data/orm/types");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const table_definitions_system_1 = require("../data/orm/table-definitions.system");
+const utils_1 = require("../utils");
+const orm_1 = require("../data/orm");
+exports.consoleLogSchema = zod_1.z.object({
+    logId: zod_types_1.zodPeerId,
+    timestamp: zod_1.z.number().default(() => (0, utils_1.getTimestamp)()).describe('The timestamp the log was created created'),
+    level: zod_1.z.enum(['debug', 'info', 'log', 'warn', 'error']).describe('The log level'),
+    process: zod_1.z.string().describe('The process that generated the log (e.g., main, renderer, worker)'),
+    processInstanceId: zod_1.z.string().describe('Unique ID for this process instance to filter own logs'),
+    source: zod_1.z.string().optional().describe('The source file or module that generated the log'),
+    message: zod_1.z.string().describe('The log message'),
+    context: zod_types_1.zodAnyObject.optional().describe('Additional structured context data'),
+    stackTrace: zod_1.z.string().optional().describe('Stack trace for errors'),
+});
+const metaData = {
+    name: 'ConsoleLogs',
+    description: 'System-wide console log entries with cross-process visibility.',
+    primaryKeyName: 'logId',
+    fields: (0, types_1.schemaToFields)(exports.consoleLogSchema),
+    localOnly: true, // Don't sync logs between devices
+    indexes: [
+        { fields: ['timestamp'] },
+        { fields: ['level'] },
+        { fields: ['process'] },
+        { fields: ['processInstanceId'] },
+    ],
+};
+let ConsoleLogsTable = (() => {
+    let _classSuper = orm_1.Table;
+    let _instanceExtraInitializers = [];
+    let _initializeLogCleanup_decorators;
+    let _deleteOldLogs_decorators;
+    return class ConsoleLogsTable extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _initializeLogCleanup_decorators = [(0, orm_1.ProxyClientTableMethodCalls)()];
+            _deleteOldLogs_decorators = [(0, orm_1.ProxyClientTableMethodCalls)()];
+            __esDecorate(this, null, _initializeLogCleanup_decorators, { kind: "method", name: "initializeLogCleanup", static: false, private: false, access: { has: obj => "initializeLogCleanup" in obj, get: obj => obj.initializeLogCleanup }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteOldLogs_decorators, { kind: "method", name: "deleteOldLogs", static: false, private: false, access: { has: obj => "deleteOldLogs" in obj, get: obj => obj.deleteOldLogs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        LOG_TTL = (__runInitializers(this, _instanceExtraInitializers), 7 * 24 * 60 * 60 * 1000); // 7 days
+        LOG_CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // 1 day
+        constructor(metaData, deps) {
+            super(metaData, deps);
+            if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'test') {
+                this.initializeLogCleanup();
+            }
+        }
+        logCleanupInitialized = false;
+        async initializeLogCleanup() {
+            if (this.logCleanupInitialized) {
+                return;
+            }
+            this.logCleanupInitialized = true;
+            // always cleanup old logs on startup - randomly spread out of the first 60 seconds to not slam the db
+            setTimeout(() => this.deleteOldLogs(), 60_000 * Math.random());
+            // regularly clean up logs 
+            // TODO - consider doing this as a workflow
+            setInterval(() => this.deleteOldLogs(), this.LOG_CLEANUP_INTERVAL);
+        }
+        async deleteOldLogs(cutoffTimestamp = Date.now() - 7 * 24 * 60 * 60 * 1000) {
+            const count = await this.count({ timestamp: { $lt: cutoffTimestamp } });
+            if (count === 0) {
+                console.log(`No old logs to clean up older than ${new Date(cutoffTimestamp).toISOString()}`);
+                return;
+            }
+            let ds = this.dataSource;
+            while (!(ds instanceof orm_1.SQLDataSource) && ds.dataSource) {
+                ds = ds.dataSource;
+            }
+            if (ds instanceof orm_1.SQLDataSource) {
+                const db = ds.db;
+                await db.exec(`delete from ConsoleLogs where timestamp < $timestamp`, { timestamp: cutoffTimestamp });
+                console.log(`bulk deleted ${count} logs`);
+            }
+            else {
+                const cursor = this.cursor({ timestamp: { $lt: cutoffTimestamp } }, { sortBy: ['-timestamp'] });
+                let count2 = 0;
+                for await (const log of cursor) {
+                    this.delete(log.logId);
+                }
+                console.log(`cursor deleted ${count2} logs`);
+            }
+            console.log(`cleaned up console logs`, { expectedCount: count });
+        }
+    };
+})();
+exports.ConsoleLogsTable = ConsoleLogsTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.consoleLogSchema, ConsoleLogsTable);
+/**
+ * We always use the user's personal data context so all logs are written to the same place.  This requires
+ * that the table be accessed in an asynchronous way
+ */
+async function ConsoleLogs() {
+    const userContext = await (0, user_context_singleton_1.getUserContext)();
+    return (0, user_context_singleton_1.getTableContainer)(userContext.userDataContext).getTable(metaData, exports.consoleLogSchema, ConsoleLogsTable);
+}

package/dist/logging/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./console-logger";
+export * from "./console-logs.table";

package/dist/logging/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./console-logger"), exports);
+__exportStar(require("./console-logs.table"), exports);

package/dist/rpc-types.d.ts

@@ -1,4 +1,3 @@
-import type { DataFilter, IDataQueryParams, ISaveOptions } from "./data/orm";
 export interface IEventData<T = any> {
     name: string;
     data: T;
@@ -17,16 +16,6 @@ export declare const rpcServerCalls: {
     setUserIdAndSecretKey: ((userId: string, secretKey: string) => Promise<void>);
     getUserId: () => Promise<string | undefined>;
     encryptData: ((value: string, groupId?: string) => Promise<string>);
-    tableGet: (dataContextId: string, tableName: string, id: string, opts?: {
-        useCache?: boolean;
-        cacheTtlMs?: number;
-    }) => Promise<any>;
-    tableList: ((dataContextId: string, tableName: string, filter?: DataFilter<any>, opts?: IDataQueryParams<any>) => Promise<any[]>);
-    tableCount: ((dataContextId: string, tableName: string, filter?: DataFilter<any>) => Promise<number>);
-    tableSave: ((dataContextId: string, tableName: string, record: any, opts?: ISaveOptions) => Promise<any>);
-    tableInsert: ((dataContextId: string, tableName: string, record: any) => Promise<any>);
-    tableUpdate: ((dataContextId: string, tableName: string, record: any) => Promise<any>);
-    tableDelete: ((dataContextId: string, tableName: string, recordOrId: any) => Promise<any>);
     tableMethodCall: ((dataContextId: string, tableName: string, methodName: string, ...args: any[]) => Promise<any>);
     getFileContents: ((fileId: string, encoding?: BufferEncoding) => Promise<string>);
     resetAllDeviceSyncInfo: (() => Promise<void>);

package/dist/rpc-types.js

@@ -16,14 +16,6 @@ exports.rpcServerCalls = {
     setUserIdAndSecretKey: rpcStub('setUserIdAndSecretKey'),
     getUserId: rpcStub('getUserId'),
     encryptData: rpcStub('encryptData'),
-    // TODO collapse these all down to just tableMethodCall
-    tableGet: rpcStub('tableGet'),
-    tableList: rpcStub('tableList'),
-    tableCount: rpcStub('tableCount'),
-    tableSave: rpcStub('tableSave'),
-    tableInsert: rpcStub('tableInsert'),
-    tableUpdate: rpcStub('tableUpdate'),
-    tableDelete: rpcStub('tableDelete'),
     tableMethodCall: rpcStub('tableMethodCall'),
     // TODO lock this down so not all code can get any file contents
     getFileContents: rpcStub('getFileContents'),

package/dist/types/peer-device.d.ts

@@ -7,6 +7,16 @@ export interface IPeerDevice {
     listChanges(filter?: DataFilter<IChange>, opts?: IDataQueryParams<IChange>): Promise<IChange[]>;
     getNetworkInfo(): Promise<INetworkInfo>;
     notifyOfChanges(deviceId: string, timestampLastApplied: number): Promise<void>;
+    sendDeviceMessage(message: IDeviceMessage): Promise<any>;
+}
+export interface IDeviceMessage {
+    deviceMessageId: string;
+    fromDeviceId: string;
+    toDeviceId: string;
+    dataContextId: string;
+    ttl: number;
+    payload: any;
+    signature: string;
 }
 export interface INetworkInfo {
     deviceId: string;

package/dist/users.query.d.ts

@@ -1,13 +1,15 @@
-import { DataContext, DataFilter, ICursorIterable, IUser } from "./index";
+import { DataContext, DataFilter, ICursorIterable, IUser, TrustLevel } from "./index";
 export interface IUsersQueryOpts {
     currentDataContext?: DataContext;
     includeCurrentDataContext?: boolean;
     includeUserDataContext?: boolean;
     includeOtherDataContexts?: boolean;
+    includeTrustLevel?: boolean;
 }
 export type IUserSource = 'currentDataContext' | 'userDataContext' | 'otherDataContexts';
 export interface IUserWithSource extends IUser {
     source: IUserSource;
+    trustLevel?: TrustLevel;
 }
 export declare function usersCursor(filter: DataFilter<IUser>, opts?: IUsersQueryOpts): Promise<ICursorIterable<IUserWithSource>>;
 export declare function getUserById(userId: string, opts?: IUsersQueryOpts): Promise<IUserWithSource | undefined>;

package/dist/users.query.js

@@ -4,7 +4,7 @@ exports.usersCursor = usersCursor;
 exports.getUserById = getUserById;
 const index_1 = require("./index");
 async function usersCursor(filter, opts = {}) {
-    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true } = opts;
+    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true, includeTrustLevel = true, } = opts;
     const userContext = await (0, index_1.getUserContext)();
     const contextToUse = currentDataContext || userContext.defaultDataContext();
     let finalCursor = null;
@@ -13,10 +13,12 @@ async function usersCursor(filter, opts = {}) {
         const primaryTable = (0, index_1.Users)(contextToUse);
         const primarySource = (contextToUse === userContext.userDataContext) ? 'userDataContext' : 'currentDataContext';
         const primaryCursor = index_1.Cursor.fromDataSource(primaryTable, filter)
-            .map(user => {
+            .map(async (user) => {
+            const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(contextToUse, user.userId) : undefined;
             const userWithSource = {
                 ...user,
                 source: primarySource,
+                trustLevel,
             };
             return userWithSource;
         });
@@ -26,10 +28,12 @@ async function usersCursor(filter, opts = {}) {
     if (includeUserDataContext && contextToUse !== userContext.userDataContext) {
         const userDataContextTable = (0, index_1.Users)(userContext.userDataContext);
         const userDataContextCursor = index_1.Cursor.fromDataSource(userDataContextTable, filter)
-            .map(user => {
+            .map(async (user) => {
+            const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId) : undefined;
             const userWithSource = {
                 ...user,
-                source: 'userDataContext'
+                source: 'userDataContext',
+                trustLevel,
             };
             return userWithSource;
         });
@@ -44,12 +48,26 @@ async function usersCursor(filter, opts = {}) {
             }
         }
         if (otherDataContexts.length > 0) {
+            // For trust levels from multiple contexts, we'll use the first context we find the user in
+            // This is a simplification - in reality, each group might have different trust levels
             const otherDataContextTables = otherDataContexts.map(dataContext => (0, index_1.Users)(dataContext));
             const otherDataContextsCursor = index_1.Cursor.fromDataSources(otherDataContextTables, filter)
-                .map(user => {
+                .map(async (user) => {
+                // Try to get trust level from the first group context that has this user
+                let trustLevel = undefined;
+                if (includeTrustLevel) {
+                    for (const dataContext of otherDataContexts) {
+                        const contextUser = await (0, index_1.Users)(dataContext).get(user.userId).catch(() => null);
+                        if (contextUser) {
+                            trustLevel = await (0, index_1.getUserTrustLevel)(dataContext, user.userId);
+                            break;
+                        }
+                    }
+                }
                 const userWithSource = {
                     ...user,
-                    source: 'otherDataContexts'
+                    source: 'otherDataContexts',
+                    trustLevel,
                 };
                 return userWithSource;
             });
@@ -59,7 +77,11 @@ async function usersCursor(filter, opts = {}) {
     // If no cursor was created, return empty cursor
     if (!finalCursor) {
         return index_1.Cursor.fromDataSource((0, index_1.Users)(contextToUse), { userId: { $eq: '__non_existent__' } })
-            .map(user => ({ ...user, source: 'userDataContext' }));
+            .map(async (user) => ({
+            ...user,
+            source: 'userDataContext',
+            trustLevel: includeTrustLevel ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId) : undefined
+        }));
     }
     // Deduplication by userId
     // TODO: Push deduplication logic down into the queries for better performance
@@ -73,7 +95,7 @@ async function usersCursor(filter, opts = {}) {
     });
 }
 async function getUserById(userId, opts = {}) {
-    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true } = opts;
+    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true, includeTrustLevel = true } = opts;
     const userContext = await (0, index_1.getUserContext)();
     const contextToUse = currentDataContext || userContext.defaultDataContext();
     // Try current data context first
@@ -83,9 +105,11 @@ async function getUserById(userId, opts = {}) {
             const user = await primaryTable.get(userId);
             if (user) {
                 const source = (contextToUse === userContext.userDataContext) ? 'userDataContext' : 'currentDataContext';
+                const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(contextToUse, user.userId) : undefined;
                 return {
                     ...user,
-                    source
+                    source,
+                    trustLevel,
                 };
             }
         }
@@ -99,9 +123,11 @@ async function getUserById(userId, opts = {}) {
             const userDataContextTable = (0, index_1.Users)(userContext.userDataContext);
             const user = await userDataContextTable.get(userId);
             if (user) {
+                const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId) : undefined;
                 return {
                     ...user,
-                    source: 'userDataContext'
+                    source: 'userDataContext',
+                    trustLevel,
                 };
             }
         }
@@ -117,9 +143,11 @@ async function getUserById(userId, opts = {}) {
                     const table = (0, index_1.Users)(dataContext);
                     const user = await table.get(userId);
                     if (user) {
+                        const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(dataContext, user.userId) : undefined;
                         return {
                             ...user,
-                            source: 'otherDataContexts'
+                            source: 'otherDataContexts',
+                            trustLevel,
                         };
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.7.2",
+  "version": "0.7.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"