@peers-app/peers-sdk 0.1.4

package/dist/utils.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moneyFormatter = exports.MAX_ID = exports.MIN_ID = void 0;
+exports.cryptoRandomString = cryptoRandomString;
+exports.newid = newid;
+exports.isid = isid;
+exports.idTime = idTime;
+exports.idDate = idDate;
+exports.idRandNums = idRandNums;
+exports.simpleHash = simpleHash;
+exports.simpleObjectHash = simpleObjectHash;
+exports.sleep = sleep;
+exports.camelCaseToSpaces = camelCaseToSpaces;
+exports.camelCaseToHyphens = camelCaseToHyphens;
+exports.formatMoney = formatMoney;
+exports.memoizePromise = memoizePromise;
+exports.debounceByArgs = debounceByArgs;
+exports.getTimestamp = getTimestamp;
+exports.retryOnErrorOrTimeout = retryOnErrorOrTimeout;
+exports.getFullTableName = getFullTableName;
+const _ = require("lodash");
+const nacl = require("tweetnacl");
+const peer_device_1 = require("./types/peer-device");
+const stableStringify = require('fast-json-stable-stringify');
+function cryptoRandomString(length) {
+    let s = '';
+    let r = nacl.randomBytes(length + 6);
+    let i = 0;
+    while (s.length < length) {
+        if (i >= r.length) {
+            r = nacl.randomBytes(length - s.length);
+            i = 0;
+        }
+        const n = r[i];
+        i++;
+        if (n >= 252) {
+            // we don't want to bias the characters generated so only consider the range of numbers that spread evenly between factors of 36
+            // we exclude 252, 253, 254, and 255 because it would bias towards '0', '1', '2', and '3' respectively
+            continue;
+        }
+        s += (n % 36).toString(36);
+    }
+    return s.substring(0, length);
+}
+function newid() {
+    // modeled after mongo ids, timestamp + counter + random but we're going to skip counter and have bigger random
+    // people can switch to using a counter + random later if they want (or do something else with the random part). 
+    // This id is going to be a 128 bit number so it fits naturally into memory.
+    // 2 ** 128 ~= 3.4e38 is the maximum it can be
+    // For efficient transmission, storage, presentation, and usage we're going to represent this number with base 36 [0-9a-z]
+    // (3.4e38).toString(36) == "f55n5nmuuaw00000000000000", this is our max in base 36, 25 characters
+    // Date.now() =~ 1625282091498
+    // but we're dealing in base 36 not base 10
+    // (1625282091498).toString(36) == "kqn6zrvu" (length 8)
+    // Number.parseInt("zzzzzzzz", 36) == 2821109907455 == year 2059.  Way too soon so going up to 9 characters
+    // Number.parseInt("zzzzzzzzz", 36) == 101559956668415 == year 5188.  
+    // but the max size of 9 left most can only be "f55n5nmuu" == 42720753566838 == year 3323.  That could still work but only ~ 1300 years
+    // that leaves 16 characters to represent a random number to prevent collisions each millisecond, 36 ** 16 ~= 8e24
+    // Allocating one more character to the time and one less to the random number to avoid hitting max time in any conceivable future
+    // now our max time is new Date(Number.parseInt('f55n5nmuua',36)) == +050705-08-09T23:40:06.178Z. 50k years from now.
+    // We still have 15 chars for our random number. 36 ** 15 ~= 2e23
+    // That is still a very large number and the chance of a collision should be so small as to be effectively unique in any single user's database
+    // I wish I knew the math to prove that out.
+    const time = Date.now().toString(36).padStart(10, '0'); // e.g: "00kq6xh45f", length == 10
+    //use nacl.randomBytes to be cryptographically secure
+    return time + cryptoRandomString(15);
+}
+exports.MIN_ID = '0'.repeat(25);
+; // 1970
+exports.MAX_ID = 'f55n5nmuua' + 'z'.repeat(15); // 50k years from now
+function isid(id) {
+    id = String(id);
+    const idMatch = Boolean(/^[0-9a-z]{25}$/i.exec(id));
+    if (idMatch) {
+        // only consider ids valid if they are less than current time (with 5 min buffer)
+        // This is to prevent people from making ids with times in the future to get them to always show up as the "newest" item and/or prematurely claim ids
+        return idTime(id) < (Date.now() + 300000);
+    }
+    return false;
+}
+;
+function idTime(id) {
+    const time36 = id.substr(0, 10);
+    return Number.parseInt(time36, 36);
+}
+function idDate(id) {
+    return new Date(idTime(id));
+}
+/**
+ * This returns the random number as two parts to prevent loss of precision when converting to large numbers
+ */
+function idRandNums(id) {
+    const numPart1 = id.substr(10, 8);
+    const numPart2 = id.substr(18, 7);
+    return [Number.parseInt(numPart1, 36), Number.parseInt(numPart2, 36)];
+}
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash);
+}
+function simpleObjectHash(obj) {
+    return simpleHash(stableStringify(obj));
+}
+function sleep(ms = 0) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function camelCaseToSpaces(s) {
+    s = s.replace(/([a-z])([A-Z])/g, '$1 $2');
+    // s = s.replace(/(GL)([A-Z])/g, '$1 $2');  // anything like GLAccounts, GLBatches, etc. 
+    s = s.replace("_", " ");
+    s = s[0]?.toUpperCase() + s.substr(1);
+    return s;
+}
+function camelCaseToHyphens(s) {
+    s = camelCaseToSpaces(s);
+    return s.split(' ').join('-').toLowerCase();
+}
+exports.moneyFormatter = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+function formatMoney(value, precision = 2) {
+    if (precision === 2) {
+        return exports.moneyFormatter.format(value);
+    }
+    const _moneyFormatter = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD',
+        minimumFractionDigits: precision,
+        maximumFractionDigits: precision,
+    });
+    return _moneyFormatter.format(value);
+}
+function memoizePromise(fn, opts) {
+    const cache = new Map();
+    const memoized = (...args) => {
+        const key = JSON.stringify(args);
+        if (!cache.has(key)) {
+            const promise = fn(...args).finally(() => {
+                if (opts?.cacheTtl) {
+                    setTimeout(() => {
+                        cache.delete(key);
+                    }, opts.cacheTtl);
+                }
+                else {
+                    cache.delete(key);
+                }
+            });
+            cache.set(key, promise);
+        }
+        return cache.get(key);
+    };
+    return memoized;
+}
+function debounceByArgs(fn, wait = 300) {
+    const debouncedFunctions = new Map();
+    const debounced = (...args) => {
+        const key = JSON.stringify(args);
+        if (!debouncedFunctions.has(key)) {
+            const debouncedFn = _.debounce(fn, wait);
+            debouncedFunctions.set(key, debouncedFn);
+        }
+        return debouncedFunctions.get(key)(...args);
+    };
+    return debounced;
+}
+function getTimestamp() {
+    // check if in node.js environment
+    if (typeof performance === 'undefined' || !performance.timeOrigin) {
+        // Fallback for environments without performance API
+        return Date.now();
+    }
+    return performance.timeOrigin + performance.now();
+}
+async function retryOnErrorOrTimeout({ fn, connection, opts = {}, }) {
+    const timeoutMin = opts.timeout ?? peer_device_1.PeerDeviceConsts.TIMEOUT_MIN;
+    const timeoutMax = opts.timeout ?? peer_device_1.PeerDeviceConsts.TIMEOUT_MAX;
+    const retriesOnError = opts.retriesOnError ?? peer_device_1.PeerDeviceConsts.RETRY_COUNT;
+    const retriesOnTimeout = opts.retriesOnTimeout ?? peer_device_1.PeerDeviceConsts.RETRY_COUNT;
+    const timeout = Math.round(_.clamp(connection.latencyMs * 10, timeoutMin, timeoutMax));
+    const startTime = Date.now();
+    let errorCount = 0;
+    let timeoutCount = 0;
+    let result;
+    let resultSet = false;
+    let finalError;
+    while (errorCount <= retriesOnError && timeoutCount <= retriesOnTimeout) {
+        try {
+            let sleepTimeout = null;
+            const sleepPromise = new Promise(resolve => {
+                sleepTimeout = setTimeout(() => {
+                    resolve();
+                }, timeout);
+            });
+            await Promise.race([
+                fn().then(r => {
+                    result = r;
+                    resultSet = true;
+                }),
+                sleepPromise,
+            ]);
+            clearTimeout(sleepTimeout);
+            if (resultSet) {
+                const totalTime = Date.now() - startTime;
+                connection.latencyMs = totalTime * 0.1 + connection.latencyMs * 0.9;
+                connection.errorRate = (connection.errorRate * 0.9);
+                return result;
+            }
+            // timeout *= 2; // double the timeout for the next attempt
+            timeoutCount++;
+            finalError = undefined;
+        }
+        catch (error) {
+            finalError = error;
+            connection.errorRate = (connection.errorRate * 0.9) + 0.1;
+            errorCount++;
+        }
+        console.warn(`Call failed, retrying: timeout is ${timeout}ms, errorCount: ${errorCount} of ${retriesOnError}, timeoutCount: ${timeoutCount} of ${retriesOnTimeout + 1}. Last error:`, finalError);
+    }
+    if (finalError) {
+        console.error(`Retry failed after ${errorCount} errors and ${timeoutCount} timeouts. Last error:`, finalError);
+        throw finalError;
+    }
+    else {
+        throw new Error(`Timeout after ${timeoutCount} retries waiting for ${timeout}ms`);
+    }
+}
+/**
+ * Table name is "name_id" if `id` is present, otherwise just "name"
+ */
+function getFullTableName(metaData) {
+    return [metaData.name, metaData.tableId].filter(v => v && v.length > 0).join('_');
+}

package/dist/utils.test.d.ts

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

package/dist/utils.test.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const utils_1 = require("./utils");
+describe("newid", () => {
+    it("should return a valid id", async () => {
+        const id = (0, utils_1.newid)();
+        expect((0, utils_1.isid)(id)).toBe(true);
+        const time = (0, utils_1.idTime)(id);
+        expect(time).toBeGreaterThan(Date.now() - 1000);
+        expect(time).toBeLessThan(Date.now() + 1000);
+    });
+    // NOTE: Make sure to run this if you change the random number generation
+    describe.skip("it should return ids with the random portion evenly distributed", () => {
+        it("random portion should have evenly distributed character values", async () => {
+            const buckets = {};
+            for (let i = 0; i < 1000000; i++) {
+                const randomPart = (0, utils_1.newid)().substring(10);
+                expect(randomPart.length).toBe(15);
+                for (const c of randomPart) {
+                    buckets[c] = (buckets[c] || 0) + 1;
+                }
+            }
+            console.log(buckets);
+            const counts = Object.values(buckets);
+            let average = 0;
+            let max = 0;
+            let min = Number.MAX_SAFE_INTEGER;
+            for (const c of counts) {
+                average += c;
+                max = Math.max(max, c);
+                min = Math.min(min, c);
+            }
+            average /= counts.length;
+            const maxDeviation = Math.max(max - average, average - min);
+            const maxDeviationPercent = maxDeviation / average * 100;
+            console.log({ average, max, min, maxDeviation, maxDeviationPercent });
+            // expect all values to be within 0.5% of the average
+            expect(maxDeviationPercent).toBeLessThan(0.5);
+        });
+        it("random portion should have evenly distributed character value positions", async () => {
+            const buckets = {};
+            for (let i = 0; i < 2000000; i++) {
+                const randomPart = (0, utils_1.newid)().substring(10);
+                expect(randomPart.length).toBe(15);
+                for (let j = 0; j < randomPart.length; j++) {
+                    const c = randomPart[j];
+                    const k = `${c},${String(j).padStart(2, '0')}`;
+                    buckets[k] = (buckets[k] || 0) + 1;
+                }
+            }
+            const orderedKeys = {};
+            let keys = (0, lodash_1.sortBy)(Object.keys(buckets), key => Number(key.split(',')[1]));
+            keys = (0, lodash_1.sortBy)(keys, key => key.split(',')[0]);
+            keys.forEach(key => orderedKeys[key] = buckets[key]);
+            console.log(orderedKeys);
+            const orderedValues = {};
+            let values = (0, lodash_1.sortBy)(Object.entries(buckets), ([, value]) => value);
+            values.forEach(([key, value]) => orderedValues[key] = value);
+            console.log(orderedValues);
+            const counts = Object.values(buckets);
+            let average = 0;
+            let max = 0;
+            let min = Number.MAX_SAFE_INTEGER;
+            for (const c of counts) {
+                average += c;
+                max = Math.max(max, c);
+                min = Math.min(min, c);
+            }
+            average /= counts.length;
+            const maxDeviation = Math.max(max - average, average - min);
+            const maxDeviationPercent = maxDeviation / average * 100;
+            console.log({ average, max, min, maxDeviation, maxDeviationPercent });
+            // expect all values to be within 2% of the average
+            expect(maxDeviationPercent).toBeLessThan(2);
+        });
+    });
+});
+describe("debounceByArgs", () => {
+    beforeEach(() => {
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    it("should debounce function calls with different arguments independently", () => {
+        const mockFn = jest.fn();
+        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn, 100);
+        debouncedFn(1);
+        debouncedFn(2);
+        debouncedFn(1);
+        expect(mockFn).not.toHaveBeenCalled();
+        jest.advanceTimersByTime(100);
+        expect(mockFn).toHaveBeenCalledTimes(2);
+        expect(mockFn).toHaveBeenCalledWith(1);
+        expect(mockFn).toHaveBeenCalledWith(2);
+    });
+    it("should debounce multiple calls with same arguments", () => {
+        const mockFn = jest.fn();
+        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn, 100);
+        debouncedFn(1);
+        debouncedFn(1);
+        debouncedFn(1);
+        expect(mockFn).not.toHaveBeenCalled();
+        jest.advanceTimersByTime(100);
+        expect(mockFn).toHaveBeenCalledTimes(1);
+        expect(mockFn).toHaveBeenCalledWith(1);
+    });
+    it("should handle complex arguments", () => {
+        const mockFn = jest.fn();
+        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn, 50);
+        const obj1 = { id: 1, name: "test" };
+        const obj2 = { id: 2, name: "test" };
+        debouncedFn(obj1, "extra");
+        debouncedFn(obj2, "extra");
+        debouncedFn(obj1, "extra");
+        jest.advanceTimersByTime(50);
+        expect(mockFn).toHaveBeenCalledTimes(2);
+        expect(mockFn).toHaveBeenCalledWith(obj1, "extra");
+        expect(mockFn).toHaveBeenCalledWith(obj2, "extra");
+    });
+    it("should call the function with correct arguments after debounce", () => {
+        const mockFn = jest.fn().mockReturnValue("result");
+        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn, 100);
+        debouncedFn(1, "test");
+        expect(mockFn).not.toHaveBeenCalled();
+        jest.advanceTimersByTime(100);
+        expect(mockFn).toHaveBeenCalledTimes(1);
+        expect(mockFn).toHaveBeenCalledWith(1, "test");
+    });
+    it("should use default wait time of 300ms", () => {
+        const mockFn = jest.fn();
+        const debouncedFn = (0, utils_1.debounceByArgs)(mockFn);
+        debouncedFn(1);
+        jest.advanceTimersByTime(299);
+        expect(mockFn).not.toHaveBeenCalled();
+        jest.advanceTimersByTime(1);
+        expect(mockFn).toHaveBeenCalledTimes(1);
+    });
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@peers-app/peers-sdk",
+  "version": "0.1.4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/peers-app/peers-sdk.git"
+  },
+  "author": "Mark Archer <mark_archer@live.com>",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "xexports": {
+    ".": "./dist/index.js",
+    "./data": "./dist/data/index.js"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "dev": "tsc -w",
+    "test": "jest",
+    "deploy": "yarn build && npm version patch && npm publish && git push"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.8.0",
+    "fast-json-stable-stringify": "^2.1.0",
+    "lodash": "^4.17.21",
+    "moment": "^2.30.1",
+    "moment-timezone": "^0.5.46",
+    "tweetnacl": "^1.0.3",
+    "tweetnacl-util": "^0.15.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/jest": "^29.5.13",
+    "@types/lodash": "^4.17.7",
+    "@types/moment": "^2.13.0",
+    "@types/moment-timezone": "^0.5.30",
+    "@types/node": "^22.4.0",
+    "better-sqlite3": "^11.8.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.4.5"
+  }
+}