@peers-app/peers-sdk 0.1.4

package/dist/events.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = exports.Event = void 0;
+exports.subscribe = subscribe;
+exports.subscribeDebounce = subscribeDebounce;
+exports.emit = emit;
+exports.unionEvents = unionEvents;
+const rpc_types_1 = require("./rpc-types");
+const unitTests = process.env.NODE_ENV === 'test';
+const subscriptions = [];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function subscribe(nameOrFilter, handler) {
+    if (typeof nameOrFilter === "string") {
+        const name = nameOrFilter;
+        nameOrFilter = (evt) => evt.name === name;
+    }
+    const filter = nameOrFilter;
+    const subscription = {
+        filter,
+        handler,
+    };
+    subscriptions.push(subscription);
+    return {
+        unsubscribe: () => {
+            const iSub = subscriptions.indexOf(subscription);
+            if (iSub >= 0) {
+                subscriptions.splice(iSub, 1);
+                return true;
+            }
+            return false;
+        },
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function subscribeDebounce(nameOrFilter, handler, debounceMs) {
+    let pid = 0;
+    const handlerDebounced = (evt) => {
+        if (pid) {
+            clearTimeout(pid);
+        }
+        pid = setTimeout(() => {
+            pid = 0;
+            handler(evt);
+        }, debounceMs);
+    };
+    return subscribe(nameOrFilter, handlerDebounced);
+}
+async function emit(event, dontPropagate) {
+    const matchedHandlerPromises = subscriptions
+        .filter((subscription) => subscription.filter(event))
+        .map(async (subscription) => {
+        try {
+            return await subscription.handler(event);
+        }
+        catch (err) {
+            console.error(`An unhandled error occurred in a handler while processing event: ${JSON.stringify({ event, subscription })}`, err);
+            return false;
+        }
+    });
+    // if (!(dontPropagate || unitTests)) {
+    //   matchedHandlerPromises.push(
+    //     isClient
+    //       ? rpcServerCalls.emitEvent(event).catch((err) => { console.error(`Error while propagating event to server`, err); return false; })
+    //       : rpcClientCalls.emitEvent(event).catch((err) => { console.error(`Error while propagating event to client`, err); return false; })
+    //   );
+    // }
+    if (!(dontPropagate || unitTests)) {
+        matchedHandlerPromises.push(rpc_types_1.rpcClientCalls.emitEvent(event).catch((err) => { console.error(`Error while propagating event to client`, err); return false; }));
+    }
+    const results = await Promise.all(matchedHandlerPromises);
+    // if any handlers returned false (or errored), return false, otherwise return true
+    return !results.some((r) => r === false);
+}
+if (rpc_types_1.isClient) {
+    rpc_types_1.rpcClientCalls.emitEvent = (event) => emit(event, true);
+}
+class Event {
+    _eventName;
+    constructor(_eventName) {
+        this._eventName = _eventName;
+    }
+    eventName = () => this._eventName;
+    subscribe = (handler, debounceMs) => {
+        const rawHandler = (evt) => handler(evt.data);
+        if (typeof debounceMs !== "number") {
+            return subscribe(this._eventName, rawHandler);
+        }
+        else {
+            return subscribeDebounce(this._eventName, rawHandler, debounceMs);
+        }
+    };
+    next = () => new Promise((resolve) => {
+        const sub = this.subscribe((evt) => {
+            sub.unsubscribe();
+            resolve(evt);
+        });
+    });
+    union = (event) => unionEvents(this, event);
+}
+exports.Event = Event;
+class Emitter {
+    eventName;
+    constructor(eventName) {
+        this.eventName = eventName;
+        if (eventName.includes("|")) {
+            throw new Error(`Do not use pipes in event names, they are reserved for union events`);
+        }
+        this.event = new Event(eventName);
+    }
+    event;
+    emit(data) {
+        return emit({
+            name: this.eventName,
+            data,
+        });
+    }
+}
+exports.Emitter = Emitter;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function unionEvents(...events) {
+    const eventName = events.map((s) => s.eventName()).join("|");
+    return {
+        eventName: () => eventName,
+        next: () => Promise.race(events.map((s) => s.next())),
+        subscribe: (handler) => subscribe((evt) => events.flatMap((s) => s.eventName().split("|")).includes(evt.name), (evt) => handler(evt)),
+        union: unionEvents,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export * from "./context";
+export * from "./peers-ui/peers-ui";
+export * from "./peers-ui/peers-ui.types";
+export * from "./users.query";
+export * from "./system-ids";
+export * from "./types/app-nav";
+export * from "./types/assistant-runner-args";
+export * from "./types/field-type";
+export * from "./types/peer-device";
+export * from "./types/peers-package";
+export * from "./types/workflow";
+export * from "./types/workflow-logger";
+export * from "./types/workflow-run-context";
+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/socket.type";
+export * from "./package-loader";
+export * from "./events";
+export * from "./data";
+export * as data from "./data";
+export * from "./data/orm";
+export * as orm from "./data/orm";
+export * from "./tools";
+export * as tools from "./tools";
+export * from "./keys";
+export * from "./mentions";
+export * from "./observable";
+export * from "./rpc-types";
+export * from "./serial-json";
+export * from "./utils";

package/dist/index.js

@@ -0,0 +1,50 @@
+"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 });
+exports.tools = exports.orm = exports.data = void 0;
+__exportStar(require("./context"), exports);
+__exportStar(require("./peers-ui/peers-ui"), exports);
+__exportStar(require("./peers-ui/peers-ui.types"), exports);
+__exportStar(require("./users.query"), exports);
+__exportStar(require("./system-ids"), exports);
+__exportStar(require("./types/app-nav"), exports);
+__exportStar(require("./types/assistant-runner-args"), exports);
+__exportStar(require("./types/field-type"), exports);
+__exportStar(require("./types/peer-device"), exports);
+__exportStar(require("./types/peers-package"), exports);
+__exportStar(require("./types/workflow"), exports);
+__exportStar(require("./types/workflow-logger"), exports);
+__exportStar(require("./types/workflow-run-context"), exports);
+__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/socket.type"), exports);
+__exportStar(require("./package-loader"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./data"), exports);
+exports.data = require("./data");
+__exportStar(require("./data/orm"), exports);
+exports.orm = require("./data/orm");
+__exportStar(require("./tools"), exports);
+exports.tools = require("./tools");
+__exportStar(require("./keys"), exports);
+__exportStar(require("./mentions"), exports);
+__exportStar(require("./observable"), exports);
+__exportStar(require("./rpc-types"), exports);
+__exportStar(require("./serial-json"), exports);
+__exportStar(require("./utils"), exports);

package/dist/keys.d.ts

@@ -0,0 +1,51 @@
+export declare function setPRNG(fn: (x: Uint8Array, n: number) => void): void;
+export declare function hashValue(str: string): string;
+export declare function hashBytes(buffer: Uint8Array): string;
+export declare function stableStringify(obj: any): string;
+export declare function hashObject(obj: ({
+    [key: string]: any;
+})): string;
+export declare function encodeBase64(data: Uint8Array): string;
+export declare function decodeBase64(data: string): Uint8Array;
+export declare function newToken(size?: number): string;
+export interface IPublicKeys {
+    publicKey: string;
+    publicBoxKey: string;
+}
+export interface IPublicPrivateKeys extends IPublicKeys {
+    secretKey: string;
+}
+export interface ISignedObject<T> {
+    contents: T;
+    signature: string;
+    publicKey: string;
+}
+export interface IDataBox {
+    contents: string;
+    nonce: string;
+    fromPublicKey: string;
+}
+export declare function newKeys(): IPublicPrivateKeys;
+export declare function loadKeys(secretKey: string): IPublicPrivateKeys;
+export declare function signMessageWithSecretKey(msg: string, secretKey: string): string;
+export declare function openMessageWithPublicKey(msg: string, publicKey: string): string;
+export declare function signObjectWithSecretKey<T>(obj: T, secretKey: string): ISignedObject<T>;
+export declare function openSignedObject<T>(signedObj: ISignedObject<T>): T;
+export declare function boxDataWithKeys(data: any, toPublicBoxKey: string, mySecretKey: string): IDataBox;
+export declare function openBoxWithSecretKey(box: IDataBox, mySecretKey: string): any;
+export declare function encryptData<T>(data: T, secretKey: string): string;
+export declare function decryptData<T>(encryptedData: string, secretKey: string): (T | null);
+export type IObjectWithSignature<T> = T & {
+    signature: string;
+};
+type IMaybeSignature = {
+    signature?: string;
+};
+export declare function addSignatureToObject<T extends Record<string, any>>(obj: T, secretKey: string): IObjectWithSignature<T>;
+/**
+ * Will throw if the signature is invalid
+ */
+export declare function verifyObjectSignature<T extends IMaybeSignature>(objectWithSignature: T): void;
+export declare function isObjectSignatureValid<T extends IMaybeSignature>(objectWithSignature: T): boolean;
+export declare function getPublicKeyFromObjectSignature<T extends IMaybeSignature>(objectWithSignature: T): string | undefined;
+export {};

package/dist/keys.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPRNG = setPRNG;
+exports.hashValue = hashValue;
+exports.hashBytes = hashBytes;
+exports.stableStringify = stableStringify;
+exports.hashObject = hashObject;
+exports.encodeBase64 = encodeBase64;
+exports.decodeBase64 = decodeBase64;
+exports.newToken = newToken;
+exports.newKeys = newKeys;
+exports.loadKeys = loadKeys;
+exports.signMessageWithSecretKey = signMessageWithSecretKey;
+exports.openMessageWithPublicKey = openMessageWithPublicKey;
+exports.signObjectWithSecretKey = signObjectWithSecretKey;
+exports.openSignedObject = openSignedObject;
+exports.boxDataWithKeys = boxDataWithKeys;
+exports.openBoxWithSecretKey = openBoxWithSecretKey;
+exports.encryptData = encryptData;
+exports.decryptData = decryptData;
+exports.addSignatureToObject = addSignatureToObject;
+exports.verifyObjectSignature = verifyObjectSignature;
+exports.isObjectSignatureValid = isObjectSignatureValid;
+exports.getPublicKeyFromObjectSignature = getPublicKeyFromObjectSignature;
+const nacl = require("tweetnacl");
+const utils = require("tweetnacl-util");
+const tweetnacl_util_1 = require("tweetnacl-util");
+const serial_json_1 = require("./serial-json");
+const sha2_1 = require("@noble/hashes/sha2");
+const buffer_1 = require("buffer");
+globalThis.Buffer = buffer_1.Buffer; // shim for browsers/RN
+const _stableStringify = require('fast-json-stable-stringify');
+function setPRNG(fn) {
+    nacl.setPRNG(fn);
+}
+function hashValue(str) {
+    // const full = nacl.hash(decodeUTF8(str));
+    // const half = full.slice(0, 32);
+    // return encodeBase64(half);
+    const hash = (0, sha2_1.sha256)(new TextEncoder().encode(str));
+    return encodeBase64(hash);
+}
+;
+function hashBytes(buffer) {
+    const hash = (0, sha2_1.sha256)(buffer);
+    return encodeBase64(hash);
+}
+;
+function stableStringify(obj) {
+    return _stableStringify(obj);
+}
+function hashObject(obj) {
+    const stableJson = stableStringify(obj);
+    const hash = hashValue(stableJson);
+    return hash;
+}
+function encodeBase64(data) {
+    // return Buffer.from(data).toString("base64url"); // no padding by default
+    const str = utils.encodeBase64(data);
+    return str.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+}
+function decodeBase64(data) {
+    data = data.replace(/-/g, '+').replace(/_/g, '/');
+    while (data.length % 4 !== 0) {
+        data += '=';
+    }
+    return utils.decodeBase64(data);
+}
+function newToken(size = 32) {
+    return encodeBase64(nacl.randomBytes(size));
+}
+function newKeys() {
+    const keyPair = nacl.sign.keyPair();
+    // the first 32 bytes of the secret key are the secret part.  The second 32 bytes are the public part.
+    const secretKeyPart = keyPair.secretKey.slice(0, 32);
+    const boxKeyPair = nacl.box.keyPair.fromSecretKey(secretKeyPart);
+    return {
+        secretKey: encodeBase64(keyPair.secretKey),
+        publicKey: encodeBase64(keyPair.publicKey),
+        publicBoxKey: encodeBase64(boxKeyPair.publicKey),
+    };
+}
+function loadKeys(secretKey) {
+    let _secretKey = decodeBase64(secretKey);
+    const boxKeyPair = nacl.box.keyPair.fromSecretKey(_secretKey.slice(0, 32));
+    return {
+        secretKey: encodeBase64(_secretKey),
+        publicKey: encodeBase64(_secretKey.slice(32)),
+        publicBoxKey: encodeBase64(boxKeyPair.publicKey),
+    };
+}
+function signMessageWithSecretKey(msg, secretKey) {
+    let _secretKey = decodeBase64(secretKey);
+    const msgDecoded = (0, tweetnacl_util_1.decodeUTF8)(msg);
+    const msgSigned = nacl.sign(msgDecoded, _secretKey);
+    return encodeBase64(msgSigned);
+}
+function openMessageWithPublicKey(msg, publicKey) {
+    let _publicKey = decodeBase64(publicKey);
+    const msgDecoded = decodeBase64(msg);
+    const msgOpened = nacl.sign.open(msgDecoded, _publicKey);
+    if (!msgOpened) {
+        throw new Error('Failed to open message');
+    }
+    return (0, tweetnacl_util_1.encodeUTF8)(msgOpened);
+}
+function signObjectWithSecretKey(obj, secretKey) {
+    let _secretKey = decodeBase64(secretKey);
+    if (obj === undefined) {
+        obj = { __isUndefined: true };
+    }
+    if (obj === null) {
+        obj = { __isNull: true };
+    }
+    const objStr = (0, serial_json_1.toJSONString)(obj);
+    const objDecoded = (0, tweetnacl_util_1.decodeUTF8)(objStr);
+    const objSigned = nacl.sign.detached(objDecoded, _secretKey);
+    return {
+        contents: obj,
+        signature: encodeBase64(objSigned),
+        publicKey: encodeBase64(_secretKey.slice(32)),
+    };
+}
+function openSignedObject(signedObj) {
+    let _publicKey = decodeBase64(signedObj.publicKey);
+    const objStr = (0, serial_json_1.toJSONString)(signedObj.contents);
+    const objDecoded = (0, tweetnacl_util_1.decodeUTF8)(objStr);
+    const signature = decodeBase64(signedObj.signature);
+    const valid = nacl.sign.detached.verify(objDecoded, signature, _publicKey);
+    if (!valid) {
+        throw new Error('Signature verification failed');
+    }
+    const result = signedObj.contents;
+    if (result?.__isUndefined && Object.keys(result).length === 1) {
+        // @ts-ignore
+        return undefined;
+    }
+    if (result?.__isNull && Object.keys(result).length === 1) {
+        // @ts-ignore
+        return null;
+    }
+    return signedObj.contents;
+}
+function boxDataWithKeys(data, toPublicBoxKey, mySecretKey) {
+    let _secretKey = decodeBase64(mySecretKey);
+    const boxKeyPair = nacl.box.keyPair.fromSecretKey(_secretKey.slice(0, 32));
+    const _toPublicBoxKey = decodeBase64(toPublicBoxKey);
+    const nonce = nacl.randomBytes(24);
+    data = (0, serial_json_1.toJSONString)(data);
+    const dataDecoded = (0, tweetnacl_util_1.decodeUTF8)(data);
+    const dataBoxed = nacl.box(dataDecoded, nonce, _toPublicBoxKey, boxKeyPair.secretKey);
+    return {
+        contents: encodeBase64(dataBoxed),
+        nonce: encodeBase64(nonce),
+        fromPublicKey: encodeBase64(boxKeyPair.publicKey),
+    };
+}
+function openBoxWithSecretKey(box, mySecretKey) {
+    let _secretKey = decodeBase64(mySecretKey);
+    const boxKeyPair = nacl.box.keyPair.fromSecretKey(_secretKey.slice(0, 32));
+    const boxedData = decodeBase64(box.contents);
+    const nonce = decodeBase64(box.nonce);
+    const _fromPublicBoxKey = decodeBase64(box.fromPublicKey);
+    const dataAry = nacl.box.open(boxedData, nonce, _fromPublicBoxKey, boxKeyPair.secretKey);
+    if (dataAry === null) {
+        throw new Error('Message was null or verification failed');
+    }
+    const dataStr = (0, tweetnacl_util_1.encodeUTF8)(dataAry);
+    return (0, serial_json_1.fromJSONString)(dataStr);
+}
+function encryptString(data, secretKey) {
+    let _secretKey = decodeBase64(secretKey);
+    const _data = (0, tweetnacl_util_1.decodeUTF8)(data);
+    const nonce = nacl.randomBytes(24);
+    const encryptedData = nacl.secretbox(_data, nonce, _secretKey.slice(0, 32));
+    return `${encodeBase64(encryptedData)}~${encodeBase64(nonce)}`;
+}
+function decryptString(data, secretKey) {
+    let _secretKey = decodeBase64(secretKey);
+    const [encryptedData, nonce] = data.split('~');
+    const _data = decodeBase64(encryptedData);
+    const _nonce = decodeBase64(nonce);
+    const decryptedData = nacl.secretbox.open(_data, _nonce, _secretKey.slice(0, 32));
+    if (decryptedData === null) {
+        throw new Error('Failed to decrypt data');
+    }
+    return (0, tweetnacl_util_1.encodeUTF8)(decryptedData);
+}
+function encryptData(data, secretKey) {
+    const _data = (0, serial_json_1.toJSONString)(data);
+    return encryptString(_data, secretKey);
+}
+function decryptData(encryptedData, secretKey) {
+    const _data = decryptString(encryptedData, secretKey);
+    return (0, serial_json_1.fromJSONString)(_data);
+}
+function addSignatureToObject(obj, secretKey) {
+    obj = { ...obj };
+    delete obj.signature;
+    const signedObj = signObjectWithSecretKey(obj, secretKey);
+    const objSignature = `${signedObj.publicKey}:${signedObj.signature}`;
+    return { ...obj, signature: objSignature };
+}
+/**
+ * Will throw if the signature is invalid
+ */
+function verifyObjectSignature(objectWithSignature) {
+    const objWithoutSignature = { ...objectWithSignature };
+    delete objWithoutSignature.signature;
+    const [objPublicKey, objSignature] = objectWithSignature.signature?.split(':') || [];
+    const signedObject = {
+        contents: objWithoutSignature,
+        signature: objSignature,
+        publicKey: objPublicKey
+    };
+    openSignedObject(signedObject); // will throw if invalid  
+}
+function isObjectSignatureValid(objectWithSignature) {
+    try {
+        verifyObjectSignature(objectWithSignature);
+    }
+    catch (error) {
+        return false;
+    }
+    return true;
+}
+function getPublicKeyFromObjectSignature(objectWithSignature) {
+    const parts = objectWithSignature.signature?.split(':');
+    if (!parts || parts.length !== 2) {
+        return undefined;
+    }
+    const [publicKey] = parts;
+    return publicKey || undefined;
+}

package/dist/keys.test.d.ts

@@ -0,0 +1 @@
+export {};