@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/user-connect/connection-code.test.js

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const connection_code_1 = require("./connection-code");
-describe('connection-code', () => {
-    describe('generateConnectionCode', () => {
-        it('should generate a code with 12 characters', () => {
+describe("connection-code", () => {
+    describe("generateConnectionCode", () => {
+        it("should generate a code with 12 characters", () => {
             const result = (0, connection_code_1.generateConnectionCode)();
             expect(result.code).toHaveLength(12);
         });
-        it('should have alias of 4 characters', () => {
+        it("should have alias of 4 characters", () => {
             const result = (0, connection_code_1.generateConnectionCode)();
             expect(result.alias).toHaveLength(4);
         });
-        it('should have secret of 8 characters', () => {
+        it("should have secret of 8 characters", () => {
             const result = (0, connection_code_1.generateConnectionCode)();
             expect(result.secret).toHaveLength(8);
         });
-        it('should have code = alias + secret', () => {
+        it("should have code = alias + secret", () => {
             const result = (0, connection_code_1.generateConnectionCode)();
             expect(result.code).toBe(result.alias + result.secret);
         });
-        it('should only contain valid Crockford Base32 characters', () => {
-            const validChars = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+        it("should only contain valid Crockford Base32 characters", () => {
+            const validChars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
             for (let i = 0; i < 10; i++) {
                 const result = (0, connection_code_1.generateConnectionCode)();
                 for (const char of result.code) {
@@ -28,7 +28,7 @@ describe('connection-code', () => {
                 }
             }
         });
-        it('should generate different codes each time', () => {
+        it("should generate different codes each time", () => {
             const codes = new Set();
             for (let i = 0; i < 100; i++) {
                 codes.add((0, connection_code_1.generateConnectionCode)().code);
@@ -36,51 +36,51 @@ describe('connection-code', () => {
             expect(codes.size).toBe(100);
         });
     });
-    describe('formatConnectionCode', () => {
-        it('should format a 12-character code as XXXX-YYYY-ZZZZ', () => {
-            expect((0, connection_code_1.formatConnectionCode)('ABCD1234EFGH')).toBe('ABCD-1234-EFGH');
+    describe("formatConnectionCode", () => {
+        it("should format a 12-character code as XXXX-YYYY-ZZZZ", () => {
+            expect((0, connection_code_1.formatConnectionCode)("ABCD1234EFGH")).toBe("ABCD-1234-EFGH");
         });
-        it('should handle lowercase input', () => {
-            expect((0, connection_code_1.formatConnectionCode)('abcd1234efgh')).toBe('ABCD-1234-EFGH');
+        it("should handle lowercase input", () => {
+            expect((0, connection_code_1.formatConnectionCode)("abcd1234efgh")).toBe("ABCD-1234-EFGH");
         });
-        it('should handle input with existing dashes', () => {
-            expect((0, connection_code_1.formatConnectionCode)('ABCD-1234-EFGH')).toBe('ABCD-1234-EFGH');
+        it("should handle input with existing dashes", () => {
+            expect((0, connection_code_1.formatConnectionCode)("ABCD-1234-EFGH")).toBe("ABCD-1234-EFGH");
         });
-        it('should handle input with spaces', () => {
-            expect((0, connection_code_1.formatConnectionCode)('ABCD 1234 EFGH')).toBe('ABCD-1234-EFGH');
+        it("should handle input with spaces", () => {
+            expect((0, connection_code_1.formatConnectionCode)("ABCD 1234 EFGH")).toBe("ABCD-1234-EFGH");
         });
-        it('should throw for codes that are too short', () => {
-            expect(() => (0, connection_code_1.formatConnectionCode)('ABCD1234')).toThrow('must be 12 characters');
+        it("should throw for codes that are too short", () => {
+            expect(() => (0, connection_code_1.formatConnectionCode)("ABCD1234")).toThrow("must be 12 characters");
         });
-        it('should throw for codes that are too long', () => {
-            expect(() => (0, connection_code_1.formatConnectionCode)('ABCD1234EFGH5678')).toThrow('must be 12 characters');
+        it("should throw for codes that are too long", () => {
+            expect(() => (0, connection_code_1.formatConnectionCode)("ABCD1234EFGH5678")).toThrow("must be 12 characters");
         });
     });
-    describe('parseConnectionCode', () => {
-        it('should parse a plain 12-character code', () => {
-            const result = (0, connection_code_1.parseConnectionCode)('ABCD12345678');
-            expect(result.alias).toBe('ABCD');
-            expect(result.secret).toBe('12345678');
-        });
-        it('should parse a formatted code with dashes', () => {
-            const result = (0, connection_code_1.parseConnectionCode)('ABCD-1234-5678');
-            expect(result.alias).toBe('ABCD');
-            expect(result.secret).toBe('12345678');
-        });
-        it('should handle lowercase input', () => {
-            const result = (0, connection_code_1.parseConnectionCode)('abcd-1234-5678');
-            expect(result.alias).toBe('ABCD');
-            expect(result.secret).toBe('12345678');
-        });
-        it('should handle mixed case and spaces', () => {
-            const result = (0, connection_code_1.parseConnectionCode)('AbCd 1234 5678');
-            expect(result.alias).toBe('ABCD');
-            expect(result.secret).toBe('12345678');
-        });
-        it('should throw for invalid length', () => {
-            expect(() => (0, connection_code_1.parseConnectionCode)('ABCD1234')).toThrow('must be 12 characters');
-        });
-        it('should be the inverse of formatConnectionCode', () => {
+    describe("parseConnectionCode", () => {
+        it("should parse a plain 12-character code", () => {
+            const result = (0, connection_code_1.parseConnectionCode)("ABCD12345678");
+            expect(result.alias).toBe("ABCD");
+            expect(result.secret).toBe("12345678");
+        });
+        it("should parse a formatted code with dashes", () => {
+            const result = (0, connection_code_1.parseConnectionCode)("ABCD-1234-5678");
+            expect(result.alias).toBe("ABCD");
+            expect(result.secret).toBe("12345678");
+        });
+        it("should handle lowercase input", () => {
+            const result = (0, connection_code_1.parseConnectionCode)("abcd-1234-5678");
+            expect(result.alias).toBe("ABCD");
+            expect(result.secret).toBe("12345678");
+        });
+        it("should handle mixed case and spaces", () => {
+            const result = (0, connection_code_1.parseConnectionCode)("AbCd 1234 5678");
+            expect(result.alias).toBe("ABCD");
+            expect(result.secret).toBe("12345678");
+        });
+        it("should throw for invalid length", () => {
+            expect(() => (0, connection_code_1.parseConnectionCode)("ABCD1234")).toThrow("must be 12 characters");
+        });
+        it("should be the inverse of formatConnectionCode", () => {
             const original = (0, connection_code_1.generateConnectionCode)();
             const formatted = (0, connection_code_1.formatConnectionCode)(original.code);
             const parsed = (0, connection_code_1.parseConnectionCode)(formatted);
@@ -88,126 +88,126 @@ describe('connection-code', () => {
             expect(parsed.secret).toBe(original.secret);
         });
     });
-    describe('encryptWithSecret and decryptWithSecret', () => {
-        it('should round-trip a simple string', () => {
-            const secret = 'ABCD1234';
-            const data = 'Hello, World!';
+    describe("encryptWithSecret and decryptWithSecret", () => {
+        it("should round-trip a simple string", () => {
+            const secret = "ABCD1234";
+            const data = "Hello, World!";
             const encrypted = (0, connection_code_1.encryptWithSecret)(data, secret);
             const decrypted = (0, connection_code_1.decryptWithSecret)(encrypted, secret);
             expect(decrypted).toBe(data);
         });
-        it('should round-trip an object', () => {
-            const secret = 'ZYXW9876';
-            const data = { userId: 'user123', name: 'Test User', count: 42 };
+        it("should round-trip an object", () => {
+            const secret = "ZYXW9876";
+            const data = { userId: "user123", name: "Test User", count: 42 };
             const encrypted = (0, connection_code_1.encryptWithSecret)(data, secret);
             const decrypted = (0, connection_code_1.decryptWithSecret)(encrypted, secret);
             expect(decrypted).toEqual(data);
         });
-        it('should round-trip user connect info', () => {
-            const secret = 'TESTCODE';
+        it("should round-trip user connect info", () => {
+            const secret = "TESTCODE";
             const userInfo = {
-                userId: 'user123',
-                publicKey: 'pk_abc123',
-                publicBoxKey: 'pbk_xyz789',
-                deviceId: 'device456',
+                userId: "user123",
+                publicKey: "pk_abc123",
+                publicBoxKey: "pbk_xyz789",
+                deviceId: "device456",
             };
             const encrypted = (0, connection_code_1.encryptWithSecret)(userInfo, secret);
             const decrypted = (0, connection_code_1.decryptWithSecret)(encrypted, secret);
             expect(decrypted).toEqual(userInfo);
         });
-        it('should produce different ciphertext for same data (due to random nonce)', () => {
-            const secret = 'ABCD1234';
-            const data = 'Same data';
+        it("should produce different ciphertext for same data (due to random nonce)", () => {
+            const secret = "ABCD1234";
+            const data = "Same data";
             const encrypted1 = (0, connection_code_1.encryptWithSecret)(data, secret);
             const encrypted2 = (0, connection_code_1.encryptWithSecret)(data, secret);
             expect(encrypted1).not.toBe(encrypted2);
         });
-        it('should fail decryption with wrong secret', () => {
-            const data = 'Secret message';
-            const encrypted = (0, connection_code_1.encryptWithSecret)(data, 'CORRECT1');
-            expect(() => (0, connection_code_1.decryptWithSecret)(encrypted, 'WRONGKEY')).toThrow('Decryption failed');
+        it("should fail decryption with wrong secret", () => {
+            const data = "Secret message";
+            const encrypted = (0, connection_code_1.encryptWithSecret)(data, "CORRECT1");
+            expect(() => (0, connection_code_1.decryptWithSecret)(encrypted, "WRONGKEY")).toThrow("Decryption failed");
         });
-        it('should fail decryption with corrupted data', () => {
-            const secret = 'ABCD1234';
-            const data = 'Hello';
+        it("should fail decryption with corrupted data", () => {
+            const secret = "ABCD1234";
+            const data = "Hello";
             const encrypted = (0, connection_code_1.encryptWithSecret)(data, secret);
-            const corrupted = encrypted.slice(0, -5) + 'XXXXX';
+            const corrupted = `${encrypted.slice(0, -5)}XXXXX`;
             expect(() => (0, connection_code_1.decryptWithSecret)(corrupted, secret)).toThrow();
         });
     });
-    describe('generateConfirmationHash', () => {
+    describe("generateConfirmationHash", () => {
         const userA = {
-            userId: 'userA123',
-            publicKey: 'pkA',
-            publicBoxKey: 'pbkA',
-            deviceId: 'deviceA',
+            userId: "userA123",
+            publicKey: "pkA",
+            publicBoxKey: "pbkA",
+            deviceId: "deviceA",
         };
         const userB = {
-            userId: 'userB456',
-            publicKey: 'pkB',
-            publicBoxKey: 'pbkB',
-            deviceId: 'deviceB',
+            userId: "userB456",
+            publicKey: "pkB",
+            publicBoxKey: "pbkB",
+            deviceId: "deviceB",
         };
-        it('should return a 4-character hash', () => {
+        it("should return a 4-character hash", () => {
             const hash = (0, connection_code_1.generateConfirmationHash)(userA, userB);
             expect(hash).toHaveLength(4);
         });
-        it('should only contain valid Crockford Base32 characters', () => {
-            const validChars = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+        it("should only contain valid Crockford Base32 characters", () => {
+            const validChars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
             const hash = (0, connection_code_1.generateConfirmationHash)(userA, userB);
             for (const char of hash) {
                 expect(validChars).toContain(char);
             }
         });
-        it('should produce same hash regardless of argument order', () => {
+        it("should produce same hash regardless of argument order", () => {
             const hashAB = (0, connection_code_1.generateConfirmationHash)(userA, userB);
             const hashBA = (0, connection_code_1.generateConfirmationHash)(userB, userA);
             expect(hashAB).toBe(hashBA);
         });
-        it('should produce different hash for different users', () => {
+        it("should produce different hash for different users", () => {
             const userC = {
-                userId: 'userC789',
-                publicKey: 'pkC',
-                publicBoxKey: 'pbkC',
-                deviceId: 'deviceC',
+                userId: "userC789",
+                publicKey: "pkC",
+                publicBoxKey: "pbkC",
+                deviceId: "deviceC",
             };
             const hashAB = (0, connection_code_1.generateConfirmationHash)(userA, userB);
             const hashAC = (0, connection_code_1.generateConfirmationHash)(userA, userC);
             expect(hashAB).not.toBe(hashAC);
         });
-        it('should be deterministic', () => {
+        it("should be deterministic", () => {
             const hash1 = (0, connection_code_1.generateConfirmationHash)(userA, userB);
             const hash2 = (0, connection_code_1.generateConfirmationHash)(userA, userB);
             expect(hash1).toBe(hash2);
         });
     });
-    describe('isValidConnectionCode', () => {
-        it('should return true for valid 12-character codes', () => {
-            expect((0, connection_code_1.isValidConnectionCode)('ABCD1234EFGH')).toBe(true);
+    describe("isValidConnectionCode", () => {
+        it("should return true for valid 12-character codes", () => {
+            expect((0, connection_code_1.isValidConnectionCode)("ABCD1234EFGH")).toBe(true);
         });
-        it('should return true for codes with dashes', () => {
-            expect((0, connection_code_1.isValidConnectionCode)('ABCD-1234-EFGH')).toBe(true);
+        it("should return true for codes with dashes", () => {
+            expect((0, connection_code_1.isValidConnectionCode)("ABCD-1234-EFGH")).toBe(true);
         });
-        it('should return true for lowercase codes', () => {
-            expect((0, connection_code_1.isValidConnectionCode)('abcd1234efgh')).toBe(true);
+        it("should return true for lowercase codes", () => {
+            expect((0, connection_code_1.isValidConnectionCode)("abcd1234efgh")).toBe(true);
         });
-        it('should return true for generated codes', () => {
+        it("should return true for generated codes", () => {
             const code = (0, connection_code_1.generateConnectionCode)();
             expect((0, connection_code_1.isValidConnectionCode)(code.code)).toBe(true);
             expect((0, connection_code_1.isValidConnectionCode)((0, connection_code_1.formatConnectionCode)(code.code))).toBe(true);
         });
-        it('should return false for codes that are too short', () => {
-            expect((0, connection_code_1.isValidConnectionCode)('ABCD1234')).toBe(false);
+        it("should return false for codes that are too short", () => {
+            expect((0, connection_code_1.isValidConnectionCode)("ABCD1234")).toBe(false);
         });
-        it('should return false for codes that are too long', () => {
-            expect((0, connection_code_1.isValidConnectionCode)('ABCD1234EFGH5678')).toBe(false);
+        it("should return false for codes that are too long", () => {
+            expect((0, connection_code_1.isValidConnectionCode)("ABCD1234EFGH5678")).toBe(false);
         });
-        it('should return false for codes with invalid characters', () => {
+        it("should return false for codes with invalid characters", () => {
             // I, L, O, U are not in Crockford Base32
-            expect((0, connection_code_1.isValidConnectionCode)('ABCDILOU1234')).toBe(false);
+            expect((0, connection_code_1.isValidConnectionCode)("ABCDILOU1234")).toBe(false);
         });
-        it('should return false for empty string', () => {
-            expect((0, connection_code_1.isValidConnectionCode)('')).toBe(false);
+        it("should return false for empty string", () => {
+            expect((0, connection_code_1.isValidConnectionCode)("")).toBe(false);
         });
     });
 });

package/dist/user-connect/index.d.ts

@@ -1,3 +1,3 @@
-export * from './connection-code';
-export * from './user-connect.types';
-export * from './user-connect.pvars';
+export * from "./connection-code";
+export * from "./user-connect.pvars";
+export * from "./user-connect.types";

package/dist/user-connect/index.js

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./connection-code"), exports);
-__exportStar(require("./user-connect.types"), exports);
 __exportStar(require("./user-connect.pvars"), exports);
+__exportStar(require("./user-connect.types"), exports);

package/dist/user-connect/user-connect.pvars.js

@@ -2,31 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.userConnectCodeAnswer = exports.userConnectCodeOffer = exports.userConnectStatus = void 0;
 const persistent_vars_1 = require("../data/persistent-vars");
-exports.userConnectStatus = (0, persistent_vars_1.deviceVar)('userConnectStatus', { defaultValue: undefined });
-exports.userConnectCodeOffer = (0, persistent_vars_1.deviceVar)('userConnectCodeOffer', { defaultValue: '' });
+exports.userConnectStatus = (0, persistent_vars_1.deviceVar)("userConnectStatus", { defaultValue: undefined });
+exports.userConnectCodeOffer = (0, persistent_vars_1.deviceVar)("userConnectCodeOffer", { defaultValue: "" });
 exports.userConnectCodeOffer.loadingPromise.then(() => {
-    let codeTimeout = undefined;
-    (0, exports.userConnectStatus)('');
+    let codeTimeout;
+    (0, exports.userConnectStatus)("");
     exports.userConnectCodeOffer.subscribe(() => {
-        (0, exports.userConnectStatus)('');
+        (0, exports.userConnectStatus)("");
         clearTimeout(codeTimeout);
         if ((0, exports.userConnectCodeOffer)()) {
             codeTimeout = setTimeout(() => {
-                (0, exports.userConnectCodeOffer)('');
+                (0, exports.userConnectCodeOffer)("");
             }, 600_000); // 10 minutes
         }
     });
 });
-exports.userConnectCodeAnswer = (0, persistent_vars_1.deviceVar)('userConnectCodeAnswer', { defaultValue: '' });
+exports.userConnectCodeAnswer = (0, persistent_vars_1.deviceVar)("userConnectCodeAnswer", {
+    defaultValue: "",
+});
 exports.userConnectCodeAnswer.loadingPromise.then(() => {
-    let codeTimeout = undefined;
-    (0, exports.userConnectStatus)('');
+    let codeTimeout;
+    (0, exports.userConnectStatus)("");
     exports.userConnectCodeAnswer.subscribe(() => {
-        (0, exports.userConnectStatus)('');
+        (0, exports.userConnectStatus)("");
         clearTimeout(codeTimeout);
         if ((0, exports.userConnectCodeAnswer)()) {
             codeTimeout = setTimeout(() => {
-                (0, exports.userConnectCodeAnswer)('');
+                (0, exports.userConnectCodeAnswer)("");
             }, 600_000); // 10 minutes
         }
     });

package/dist/user-connect/user-connect.types.d.ts

@@ -19,7 +19,7 @@ export interface IUserConnectInfo {
  * The payload is encrypted with the shared secret from the connection code.
  */
 export interface IUserConnectRequest {
-    type: 'user-connect-request';
+    type: "user-connect-request";
     /** User info encrypted with the shared secret */
     encryptedUserInfo: string;
     /** The responder's deviceId so the initiator can respond directly */
@@ -30,7 +30,7 @@ export interface IUserConnectRequest {
  * The payload is encrypted with the shared secret.
  */
 export interface IUserConnectResponse {
-    type: 'user-connect-response';
+    type: "user-connect-response";
     /** User info encrypted with the shared secret */
     encryptedUserInfo: string;
 }
@@ -39,7 +39,7 @@ export interface IUserConnectResponse {
  * Other devices store this mapping for routing purposes.
  */
 export interface IDeviceAliasMessage {
-    type: 'device-alias';
+    type: "device-alias";
     /** The short alias (4 chars Crockford Base32) */
     alias: string;
     /** The actual deviceId this alias maps to */

package/dist/users.query.d.ts

@@ -1,4 +1,4 @@
-import { DataContext, DataFilter, ICursorIterable, IUser, TrustLevel, UserContext } from "./index";
+import { type DataContext, type DataFilter, type ICursorIterable, type IUser, TrustLevel, type UserContext } from "./index";
 export interface IUsersQueryOpts {
     userContext?: UserContext;
     currentDataContext?: DataContext;
@@ -7,7 +7,7 @@ export interface IUsersQueryOpts {
     includeOtherDataContexts?: boolean;
     includeTrustLevel?: boolean;
 }
-export type IUserSource = 'currentDataContext' | 'userDataContext' | 'otherDataContexts';
+export type IUserSource = "currentDataContext" | "userDataContext" | "otherDataContexts";
 export interface IUserWithSource extends IUser {
     source: IUserSource;
     trustLevel?: TrustLevel;

package/dist/users.query.js

@@ -11,10 +11,11 @@ async function usersCursor(filter, opts = {}) {
     // Include current data context
     if (includeCurrentDataContext) {
         const primaryTable = (0, index_1.Users)(contextToUse);
-        const primarySource = (contextToUse === userContext.userDataContext) ? 'userDataContext' : 'currentDataContext';
-        const primaryCursor = index_1.Cursor.fromDataSource(primaryTable, filter)
-            .map(async (user) => {
-            const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(contextToUse, user.userId) : undefined;
+        const primarySource = contextToUse === userContext.userDataContext ? "userDataContext" : "currentDataContext";
+        const primaryCursor = index_1.Cursor.fromDataSource(primaryTable, filter).map(async (user) => {
+            const trustLevel = includeTrustLevel
+                ? await (0, index_1.getUserTrustLevel)(contextToUse, user.userId)
+                : undefined;
             const userWithSource = {
                 ...user,
                 source: primarySource,
@@ -27,12 +28,13 @@ async function usersCursor(filter, opts = {}) {
     // Include user data context (if different from current and requested)
     if (includeUserDataContext && contextToUse !== userContext.userDataContext) {
         const userDataContextTable = (0, index_1.Users)(userContext.userDataContext);
-        const userDataContextCursor = index_1.Cursor.fromDataSource(userDataContextTable, filter)
-            .map(async (user) => {
-            const trustLevel = includeTrustLevel ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId) : undefined;
+        const userDataContextCursor = index_1.Cursor.fromDataSource(userDataContextTable, filter).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;
@@ -50,14 +52,15 @@ 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(async (user) => {
+            const otherDataContextTables = otherDataContexts.map((dataContext) => (0, index_1.Users)(dataContext));
+            const otherDataContextsCursor = index_1.Cursor.fromDataSources(otherDataContextTables, filter).map(async (user) => {
                 // Try to get trust level from the first group context that has this user
-                let trustLevel = undefined;
+                let trustLevel;
                 if (includeTrustLevel) {
                     for (const dataContext of otherDataContexts) {
-                        const contextUser = await (0, index_1.Users)(dataContext).get(user.userId).catch(() => null);
+                        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;
@@ -66,20 +69,21 @@ async function usersCursor(filter, opts = {}) {
                 }
                 const userWithSource = {
                     ...user,
-                    source: 'otherDataContexts',
+                    source: "otherDataContexts",
                     trustLevel,
                 };
                 return userWithSource;
             });
-            finalCursor = finalCursor ? finalCursor.union(otherDataContextsCursor) : otherDataContextsCursor;
+            finalCursor = finalCursor
+                ? finalCursor.union(otherDataContextsCursor)
+                : otherDataContextsCursor;
         }
     }
     // 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(async (user) => ({
+        return index_1.Cursor.fromDataSource((0, index_1.Users)(contextToUse), { userId: { $eq: "__non_existent__" } }).map(async (user) => ({
             ...user,
-            source: 'userDataContext',
+            source: "userDataContext",
             trustLevel: index_1.TrustLevel.Unknown,
         }));
     }
@@ -92,7 +96,7 @@ async function usersCursor(filter, opts = {}) {
         }
         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 
+            // 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);
@@ -105,8 +109,8 @@ async function usersCursor(filter, opts = {}) {
     });
 }
 async function getUserById(userId, opts = {}) {
-    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true, includeTrustLevel = true } = opts;
-    const userContext = opts.userContext || await (0, index_1.getUserContext)();
+    const { currentDataContext, includeCurrentDataContext = true, includeUserDataContext = true, includeOtherDataContexts = true, includeTrustLevel = true, } = opts;
+    const userContext = opts.userContext || (await (0, index_1.getUserContext)());
     const contextToUse = currentDataContext || userContext.defaultDataContext();
     // Try current data context first
     if (includeCurrentDataContext) {
@@ -114,8 +118,10 @@ async function getUserById(userId, opts = {}) {
             const primaryTable = (0, index_1.Users)(contextToUse);
             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;
+                const source = contextToUse === userContext.userDataContext ? "userDataContext" : "currentDataContext";
+                const trustLevel = includeTrustLevel
+                    ? await (0, index_1.getUserTrustLevel)(contextToUse, user.userId)
+                    : undefined;
                 return {
                     ...user,
                     source,
@@ -123,7 +129,7 @@ async function getUserById(userId, opts = {}) {
                 };
             }
         }
-        catch (error) {
+        catch (_error) {
             // User not found in this context, continue to next
         }
     }
@@ -133,15 +139,17 @@ 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;
+                const trustLevel = includeTrustLevel
+                    ? await (0, index_1.getUserTrustLevel)(userContext.userDataContext, user.userId)
+                    : undefined;
                 return {
                     ...user,
-                    source: 'userDataContext',
+                    source: "userDataContext",
                     trustLevel,
                 };
             }
         }
-        catch (error) {
+        catch (_error) {
             // User not found in this context, continue to next
         }
     }
@@ -153,15 +161,17 @@ 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;
+                        const trustLevel = includeTrustLevel
+                            ? await (0, index_1.getUserTrustLevel)(dataContext, user.userId)
+                            : undefined;
                         return {
                             ...user,
-                            source: 'otherDataContexts',
+                            source: "otherDataContexts",
                             trustLevel,
                         };
                     }
                 }
-                catch (error) {
+                catch (_error) {
                     // User not found in this context, continue to next
                 }
             }

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { IDeviceConnection } from './types/peer-device';
-import type { ITableMetaData } from './data/orm';
+import type { ITableMetaData } from "./data/orm";
+import { type IDeviceConnection } from "./types/peer-device";
 export declare function cryptoRandomString(length: number): string;
 export declare function newid(): string;
 export declare const MIN_ID: string;