@peers-app/peers-sdk 0.7.23 → 0.7.24

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

@@ -15,6 +15,7 @@ export declare class UserContext {
     readonly groupDataContexts: Map<string, DataContext>;
     readonly defaultDataContext: Observable<DataContext>;
     readonly loadingPromise: Promise<UserContext>;
+    private personalUserSubscription?;
     constructor(userId: string, dataSourceFactory: DataSourceFactory, ephemeral?: boolean | undefined);
     private init;
     /**
@@ -41,6 +42,7 @@ export declare class UserContext {
     subscribeToDataChangedAcrossAllGroups<T extends {
         [key: string]: any;
     }>(table: string | Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;
+    dispose(): void;
 }
 export interface ICrossGroupSubscriptionHandlerArgs<T> {
     name: string;

package/dist/context/user-context.js

@@ -20,6 +20,7 @@ class UserContext {
     groupDataContexts = new Map();
     defaultDataContext;
     loadingPromise;
+    personalUserSubscription;
     constructor(userId, dataSourceFactory, ephemeral) {
         this.userId = userId;
         this.dataSourceFactory = dataSourceFactory;
@@ -143,11 +144,10 @@ class UserContext {
         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')
             console.warn(`My user object was not in db, creating now`);
             me = {
                 userId,
-                name: 'Unnamed_1',
+                name: 'Unnamed_' + userId.slice(20),
                 publicKey: '',
                 publicBoxKey: '',
             };
@@ -160,7 +160,7 @@ class UserContext {
             (0, keys_1.verifyObjectSignature)(meSigned);
             await (0, data_1.Users)(userContext.userDataContext).save(meSigned);
         }
-        // sync my user to all all my groups
+        // sync my user to all my groups
         for (const [, dataContext] of userContext.groupDataContexts) {
             let groupMe = await (0, data_1.Users)(dataContext).get(me.userId);
             if (!(0, lodash_1.isEqual)(groupMe, meSigned)) {
@@ -186,6 +186,23 @@ class UserContext {
                 await (0, data_1.Groups)(this.userDataContext).save(groupObject);
             }
         }
+        if (!this.personalUserSubscription) {
+            this.personalUserSubscription = this.subscribeToDataChangedAcrossAllGroups('Users', async (evt) => {
+                const changedUser = evt.data.dataObject;
+                if (changedUser.userId !== this.userId) {
+                    // sync to my personal db if this is a user that I have there
+                    const personalUser = await (0, data_1.Users)(this.userDataContext).get(changedUser.userId);
+                    if (personalUser && !(0, lodash_1.isEqual)(personalUser, changedUser)) {
+                        try {
+                            await (0, data_1.Users)(this.userDataContext).save(changedUser);
+                        }
+                        catch (err) {
+                            console.error(`Error saving user ${changedUser.userId} to personal db:`, err);
+                        }
+                    }
+                }
+            });
+        }
     }
     subscribeToDataChangedAcrossAllGroups(table, handler) {
         const tableName = typeof table === 'string' ? table : table.tableName;
@@ -202,5 +219,8 @@ class UserContext {
         });
         return subscription;
     }
+    dispose() {
+        this.personalUserSubscription?.unsubscribe();
+    }
 }
 exports.UserContext = UserContext;

package/dist/device/connection.d.ts

@@ -17,6 +17,8 @@ export declare class Connection {
     timeoutMs: number;
     maxChunkSize: number;
     handshakeTimestampToleranceMs: number;
+    private _connectionAddress;
+    get connectionAddress(): string | undefined;
     readonly socket: ISocket;
     constructor(socket: ISocket, localDevice: Device, localDeviceServerAddresses?: string[] | undefined, getTrustLevel?: GetTrustLevel);
     get verified(): boolean;
@@ -38,6 +40,7 @@ export declare class Connection {
     completeHandshake(boxedHandshake: IDataBox): Promise<IDeviceHandshake>;
     doHandshake(remoteAddress: string): Promise<IDeviceHandshake>;
     private closeLocal;
+    ping(): Promise<number>;
     private closed;
     close(): Promise<void>;
 }

package/dist/device/connection.js

@@ -30,6 +30,10 @@ class Connection {
     timeoutMs = 60_000; // 60 seconds
     maxChunkSize = socket_type_1.DEFAULT_MAX_CHUNK_SIZE;
     handshakeTimestampToleranceMs = HANDSHAKE_TIMESTAMP_TOLERANCE_MS;
+    _connectionAddress;
+    get connectionAddress() {
+        return this._connectionAddress;
+    }
     socket;
     constructor(socket, localDevice, localDeviceServerAddresses, getTrustLevel = () => Promise.resolve(socket_type_1.TrustLevel.Unknown)) {
         this.localDevice = localDevice;
@@ -47,6 +51,9 @@ class Connection {
                 this.closeLocal();
             });
         });
+        this.exposeRPC('ping', () => {
+            return Date.now();
+        });
         if (localDeviceServerAddresses) {
             this.exposeRPC('reset', this.reset.bind(this));
             this.exposeRPC('getTrustLevel', async (deviceInfo) => {
@@ -171,6 +178,7 @@ class Connection {
         this.socket.removeAllListeners(eventName);
     }
     reset() {
+        this._connectionAddress = undefined;
         this._remoteDeviceInfo = {
             deviceId: '',
             userId: '',
@@ -203,6 +211,7 @@ class Connection {
             'unknown';
         // only set local secure if the server address matches the client's address and the address is using https
         this.secureLocal = clientServerAddress === thisServerAddress && thisServerAddress.startsWith('https');
+        this._connectionAddress = thisServerAddress;
         const handshakeResponse = this.localDevice.handshakeResponse(signedHandshake, this.connectionId, thisServerAddress);
         this._remoteDeviceInfo = {
             userId: _handshake.userId,
@@ -212,6 +221,8 @@ class Connection {
         };
         this.trustLevel = await this.getTrustLevel(signedHandshake.contents, true);
         if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
+            this.reset();
+            this.emit('reset');
             throw new Error('Untrusted connection');
         }
         console.log(`Connection ${this.connectionId} verified on server side with trust level ${this.trustLevel}`);
@@ -242,6 +253,7 @@ class Connection {
             throw new Error('Inconsistent device info');
         }
         this._verified = true;
+        this._connectionAddress = remoteAddress;
         this.secureLocal = handshakeResponse.serverAddress === remoteAddress && remoteAddress.startsWith('https');
         if (this.secureLocal) {
             await this.emit('requestSecure');
@@ -260,6 +272,14 @@ class Connection {
         this.removeAllListeners();
         this.socket.disconnect(true);
     }
+    async ping() {
+        if (!this._verified) {
+            throw new Error('Cannot ping unverified connection');
+        }
+        const startTime = Date.now();
+        await this.emit('ping');
+        return Date.now() - startTime;
+    }
     closed = false;
     async close() {
         if (this.closed)
@@ -267,7 +287,8 @@ class Connection {
         this.closed = true;
         await Promise.race([
             this.emit('close').catch(err => {
-                console.error('Error sending close event to remote device', err);
+                // swallow error
+                // console.error('Error sending close event to remote device', err);
             }),
             (0, utils_1.sleep)(100),
         ]);

package/dist/device/get-trust-level-fn.d.ts

@@ -0,0 +1,3 @@
+import { IDeviceInfo } from "../data";
+import { TrustLevel } from "./socket.type";
+export declare function getTrustLevelFn(me: Pick<IDeviceInfo, 'userId' | 'publicKey' | 'publicBoxKey'>, serverUrl?: string): (deviceInfo: IDeviceInfo, registerNew?: boolean) => Promise<TrustLevel>;

package/dist/device/{get-trust-level.js → get-trust-level-fn.js}

@@ -8,6 +8,7 @@ function getTrustLevelFn(me, serverUrl) {
     return async function getTrustLevel(deviceInfo, registerNew) {
         const userContext = await (0, context_1.getUserContext)();
         const userDataContext = userContext.userDataContext;
+        // if this is my own device it is trusted
         if (deviceInfo.userId === me.userId && deviceInfo.publicKey === me.publicKey && deviceInfo.publicBoxKey === me.publicBoxKey) {
             // if (deviceInfo.deviceId === thisDeviceId()) {
             //   return TrustLevel.Untrusted;
@@ -23,53 +24,67 @@ function getTrustLevelFn(me, serverUrl) {
             device.lastSeen = new Date();
             device.trustLevel = socket_type_1.TrustLevel.Trusted;
             console.log(`Updating my own device: ${deviceInfo.deviceId}`);
-            await (0, data_1.Devices)(userDataContext).save(device);
+            await (0, data_1.Devices)(userDataContext).save(device, { restoreIfDeleted: true });
             return socket_type_1.TrustLevel.Trusted;
         }
-        // await Devices().delete(deviceInfo.deviceId);
         let [user, device, userTrustLevel] = await Promise.all([
             (0, data_1.Users)(userDataContext).get(deviceInfo.userId),
             (0, data_1.Devices)(userDataContext).get(deviceInfo.deviceId),
             (0, data_1.UserTrustLevels)(userDataContext).get(deviceInfo.userId),
         ]);
+        if (device && device.trustLevel < socket_type_1.TrustLevel.Unknown) {
+            // If device is untrusted, return immediately
+            return device.trustLevel;
+        }
+        // TODO check user trust level, if they are untrusted, return immediately
         if (user && device && !(deviceInfo.userId === device.userId && deviceInfo.userId === user.userId && deviceInfo.publicKey === user.publicKey && deviceInfo.publicBoxKey === user.publicBoxKey)) {
-            console.error(new Date().toISOString(), 'deviceInfo does not align with local info about user and device', { deviceInfo, user, device });
+            // deviceInfo does not align with local info about user and device, return Untrusted
             // TODO check if user has changed their public keys
             return socket_type_1.TrustLevel.Untrusted;
         }
         if (userTrustLevel?.trustLevel && userTrustLevel.trustLevel >= socket_type_1.TrustLevel.Trusted && device?.trustLevel && device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
             device.lastSeen = new Date();
-            await (0, data_1.Devices)(userDataContext).update(device);
+            await (0, data_1.Devices)(userDataContext).save(device, { restoreIfDeleted: true });
             return socket_type_1.TrustLevel.Trusted;
         }
-        let trustLevel = device?.trustLevel ?? socket_type_1.TrustLevel.Known;
+        let trustLevel = device?.trustLevel ?? socket_type_1.TrustLevel.Unknown;
+        const lastSeen = new Date();
         if (!device) {
             device = {
                 deviceId: deviceInfo.deviceId,
                 userId: deviceInfo.userId,
-                firstSeen: new Date(),
-                lastSeen: new Date(),
+                firstSeen: lastSeen,
+                lastSeen,
                 serverUrl,
-                trustLevel: socket_type_1.TrustLevel.Unknown,
+                trustLevel: socket_type_1.TrustLevel.NewDevice,
             };
-            trustLevel = socket_type_1.TrustLevel.NewDevice;
         }
         else {
-            device.lastSeen = new Date();
+            device.lastSeen = lastSeen;
+            if (device.trustLevel < socket_type_1.TrustLevel.NewDevice) {
+                device.trustLevel = socket_type_1.TrustLevel.NewDevice;
+            }
+            const knownThreshold = 1000 * 60 * 60 * 24 * 7; // 7 days
+            const passedKnownThreshold = Date.now() - device.firstSeen.getTime() > knownThreshold;
+            // const passedKnownThreshold = true; // TODO - for testing, remove
+            if (passedKnownThreshold && device.trustLevel < socket_type_1.TrustLevel.Known) {
+                device.trustLevel = socket_type_1.TrustLevel.Known;
+            }
         }
+        trustLevel = device.trustLevel;
         let newUser = false;
         if (!user) {
             user = {
                 userId: deviceInfo.userId,
                 publicKey: deviceInfo.publicKey,
                 publicBoxKey: deviceInfo.publicBoxKey,
-                name: serverUrl || deviceInfo.userId,
+                name: serverUrl || `Unnamed_${deviceInfo.userId.substring(20)}`,
             };
             trustLevel = socket_type_1.TrustLevel.NewUser;
             newUser = true;
         }
-        let remoteTrustLevel = socket_type_1.TrustLevel.Unknown;
         // TODO - reimplement this, checks with peers to see if this is an untrusted device
+        // let remoteTrustLevel = TrustLevel.Unknown;
         // for (const [serverUrl, conn] of Object.entries(getActiveConnections())) {
         //   if (conn.trustLevel >= TrustLevel.Trusted) {
         //     const _remoteTrustLevel: TrustLevel = await conn.emit('getTrustLevel', deviceInfo).catch(err => {
@@ -89,18 +104,19 @@ function getTrustLevelFn(me, serverUrl) {
         //     }
         //   }
         // }
-        if (remoteTrustLevel > socket_type_1.TrustLevel.Unknown && !userTrustLevel) {
-            await (0, data_1.UserTrustLevels)(userDataContext).save({
-                userId: deviceInfo.userId,
-                trustLevel: socket_type_1.TrustLevel.Known,
-                assignedAt: new Date(),
-            });
-        }
-        else if (newUser) {
-            await (0, data_1.Users)(userDataContext).save(user);
+        // if (remoteTrustLevel && !userTrustLevel) {
+        //   await UserTrustLevels(userDataContext).save({
+        //     userId: deviceInfo.userId,
+        //     trustLevel: remoteTrustLevel,
+        //     assignedAt: new Date(),
+        //   }, { restoreIfDeleted: true });
+        // } 
+        if (newUser) {
+            // TODO: I'm not sure we immediately want to save this user to the my personal db...
+            await (0, data_1.Users)(userDataContext).save(user, { restoreIfDeleted: true });
         }
-        device.trustLevel = remoteTrustLevel || trustLevel;
-        await (0, data_1.Devices)(userDataContext).save(device);
+        // device.trustLevel = remoteTrustLevel || trustLevel;
+        await (0, data_1.Devices)(userDataContext).save(device, { restoreIfDeleted: true });
         return device.trustLevel;
     };
 }

package/dist/index.d.ts

@@ -15,7 +15,7 @@ export * from "./types/zod-types";
 export * from "./device/connection";
 export * from "./device/device";
 export * from "./device/device-election";
-export * from "./device/get-trust-level";
+export * from "./device/get-trust-level-fn";
 export * from "./device/socket.type";
 export * from "./device/tx-encoding";
 export * from "./package-loader";

package/dist/index.js

@@ -32,7 +32,7 @@ __exportStar(require("./types/zod-types"), exports);
 __exportStar(require("./device/connection"), exports);
 __exportStar(require("./device/device"), exports);
 __exportStar(require("./device/device-election"), exports);
-__exportStar(require("./device/get-trust-level"), exports);
+__exportStar(require("./device/get-trust-level-fn"), exports);
 __exportStar(require("./device/socket.type"), exports);
 __exportStar(require("./device/tx-encoding"), exports);
 __exportStar(require("./package-loader"), exports);

package/dist/users.query.js

@@ -80,16 +80,26 @@ async function usersCursor(filter, opts = {}) {
             .map(async (user) => ({
             ...user,
             source: 'userDataContext',
-            trustLevel: includeTrustLevel ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId) : undefined
+            trustLevel: index_1.TrustLevel.Unknown,
         }));
     }
     // Deduplication by userId
     // TODO: Push deduplication logic down into the queries for better performance
     const userIdsSeen = new Set();
-    return finalCursor.filter(user => {
+    return finalCursor.filter(async (user) => {
         if (userIdsSeen.has(user.userId)) {
             return false;
         }
+        if (includeTrustLevel) {
+            // use personal trust level if I have one
+            // TODO: Review this, I think this makes sense but it could create scenarios where I am unintentionally 
+            //       trusting another user too much just because a group I'm in has given them a high trust rating
+            // IDEA: Assign a trust level to _groups_ and then user trust levels from that group are capped at that level
+            const personalTrustLevel = await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId);
+            if (personalTrustLevel) {
+                user.trustLevel = personalTrustLevel;
+            }
+        }
         userIdsSeen.add(user.userId);
         return true;
     });

package/package.json

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

package/dist/device/get-trust-level.d.ts

@@ -1,3 +0,0 @@
-import { IDeviceInfo, IUser } from "../data";
-import { TrustLevel } from "./socket.type";
-export declare function getTrustLevelFn(me: IUser, serverUrl?: string): (deviceInfo: IDeviceInfo, registerNew?: boolean) => Promise<TrustLevel>;