@bitblit/ratchet-common 4.0.115-alpha → 4.0.119-alpha

package/lib/network/browser-local-ip-provider.spec.js

@@ -1,16 +0,0 @@
-import { BrowserLocalIpProvider } from './browser-local-ip-provider.js';
-import { NetworkRatchet } from './network-ratchet.js';
-import { PromiseRatchet } from '../lang/promise-ratchet.js';
-import { jest } from '@jest/globals';
-jest.mock('./network-ratchet');
-describe('#browserLocalIpProvider', function () {
-    it('should pull a local ip and return it', async () => {
-        const mockStaticFn = jest.fn(() => Promise.resolve('192.168.1.1'));
-        NetworkRatchet.findLocalIp = mockStaticFn;
-        const up = new BrowserLocalIpProvider();
-        while (!up.ready()) {
-            await PromiseRatchet.wait(250);
-        }
-        expect(up.currentLocalIpAddress()).toEqual('192.168.1.1');
-    });
-});

package/lib/network/fixed-local-ip-provider.js

@@ -1,9 +0,0 @@
-export class FixedLocalIpProvider {
-    fixed;
-    constructor(fixed) {
-        this.fixed = fixed;
-    }
-    currentLocalIpAddress() {
-        return this.fixed;
-    }
-}

package/lib/network/local-ip-provider.js

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

package/lib/network/network-ratchet.js

@@ -1,102 +0,0 @@
-import { Logger } from '../logger/logger.js';
-export class NetworkRatchet {
-    static LOCAL_IP = null;
-    static findLocalIp(useCache = true) {
-        Logger.info('Attempting to find local IP (V 2)');
-        if (NetworkRatchet.LOCAL_IP && useCache) {
-            return Promise.resolve(NetworkRatchet.LOCAL_IP);
-        }
-        else {
-            if (typeof window !== 'undefined') {
-                return new Promise(function (resolve, reject) {
-                    try {
-                        const RTCPeerConnection = window['RTCPeerConnection'] || window['webkitRTCPeerConnection'] || window['mozRTCPeerConnection'];
-                        if (RTCPeerConnection) {
-                            const rtc = new RTCPeerConnection({ iceServers: [] });
-                            const addrs = Object.create(null);
-                            addrs['0.0.0.0'] = false;
-                            if (1 || window['mozRTCPeerConnection']) {
-                                rtc.createDataChannel('', { reliable: false });
-                            }
-                            rtc.onicecandidate = function (evt) {
-                                if (evt.candidate) {
-                                    NetworkRatchet.grepSDP('a=' + evt.candidate.candidate, addrs, resolve);
-                                }
-                            };
-                            rtc.createOffer(function (offerDesc) {
-                                NetworkRatchet.grepSDP(offerDesc.sdp, addrs, resolve);
-                                rtc.setLocalDescription(offerDesc);
-                            }, function (e) {
-                                Logger.warn('Offer failed : %s', e);
-                                resolve(NetworkRatchet.updateLocalIP('FIND_UNSUPPORTED'));
-                            });
-                        }
-                        else {
-                            Logger.warn('IP Address find not supported on this device');
-                            resolve(NetworkRatchet.updateLocalIP('FIND_UNSUPPORTED'));
-                        }
-                    }
-                    catch (err) {
-                        Logger.warn('Error finding local ip address : %s', err);
-                        resolve(NetworkRatchet.updateLocalIP('ERROR'));
-                    }
-                });
-            }
-            else {
-                Logger.warn('Window not found, cannot calculate local ip');
-                return Promise.resolve(NetworkRatchet.updateLocalIP('NO_WINDOW'));
-            }
-        }
-    }
-    static parseUrl(href) {
-        const match = href.match(/^(https?\:)\/\/(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/);
-        const rval = match &&
-            {
-                href: href,
-                protocol: match[1],
-                host: match[2],
-                hostname: match[3],
-                port: match[4],
-                pathname: match[5],
-                search: match[6],
-                hash: match[7],
-            };
-        return rval;
-    }
-    static updateLocalIP(newIp) {
-        NetworkRatchet.LOCAL_IP = newIp;
-        return NetworkRatchet.LOCAL_IP;
-    }
-    static grepSDP(sdp, addrs, resolve) {
-        const hosts = [];
-        sdp.split('\r\n').forEach(function (line) {
-            if (~line.indexOf('a=candidate')) {
-                const parts = line.split(' '), addr = parts[4], type = parts[7];
-                if (type === 'host') {
-                    NetworkRatchet.updateAddressList(addr, addrs, resolve);
-                }
-            }
-            else if (~line.indexOf('c=')) {
-                const parts = line.split(' '), addr = parts[2];
-                NetworkRatchet.updateAddressList(addr, addrs, resolve);
-            }
-        });
-    }
-    static updateAddressList(newAddr, addrs, resolve) {
-        if (newAddr in addrs)
-            return;
-        else
-            addrs[newAddr] = true;
-        const displayAddrs = Object.keys(addrs).filter(function (k) {
-            return addrs[k];
-        });
-        if (displayAddrs && displayAddrs.length == 1) {
-            resolve(NetworkRatchet.updateLocalIP(displayAddrs[0]));
-        }
-        else {
-            const multi = displayAddrs.sort().join(',');
-            Logger.warn('Multiple addresses found, returning sorted join : %s', multi);
-            resolve(NetworkRatchet.updateLocalIP(multi));
-        }
-    }
-}

package/lib/network/network-ratchet.spec.js

@@ -1,13 +0,0 @@
-import { NetworkRatchet } from './network-ratchet.js';
-describe('#parseUrl', function () {
-    it('should parse the url and return correct values', function () {
-        const result = NetworkRatchet.parseUrl('http://example.com:3000/pathname/?search=test#hash');
-        expect(result.protocol).toEqual('http:');
-        expect(result.host).toEqual('example.com:3000');
-        expect(result.hostname).toEqual('example.com');
-        expect(result.port).toEqual('3000');
-        expect(result.pathname).toEqual('/pathname/');
-        expect(result.search).toEqual('?search=test');
-        expect(result.hash).toEqual('#hash');
-    });
-});

package/lib/stream/buffer-writable.js

@@ -1,16 +0,0 @@
-import { Writable } from 'stream';
-export class BufferWritable extends Writable {
-    _val = [];
-    constructor() {
-        super();
-    }
-    _write(chunk, encoding, callback) {
-        if (chunk) {
-            this._val.push(chunk);
-        }
-        callback();
-    }
-    get value() {
-        return Buffer.concat(this._val);
-    }
-}

package/lib/stream/multi-stream.js

@@ -1,12 +0,0 @@
-import { Readable } from 'stream';
-export class MultiStream extends Readable {
-    _object;
-    constructor(object, options = {}) {
-        super(object instanceof Buffer || typeof object === 'string' ? options : { objectMode: true });
-        this._object = object;
-    }
-    _read() {
-        this.push(this._object);
-        this._object = null;
-    }
-}

package/lib/stream/stream-ratchet.js

@@ -1,68 +0,0 @@
-import { Readable } from 'stream';
-import { ErrorRatchet } from '../lang/error-ratchet.js';
-import { StringRatchet } from '../lang/string-ratchet.js';
-export class StreamRatchet {
-    constructor() { }
-    static readableToBufferSync(stream) {
-        const bufs = [];
-        let next = stream.read();
-        while (next) {
-            bufs.push(next);
-            next = stream.read();
-        }
-        return Buffer.concat(bufs);
-    }
-    static async webReadableStreamToBuffer(stream) {
-        const out = [];
-        const writer = new WritableStream({
-            async write(chunk, controller) {
-                if (typeof chunk === 'string') {
-                    StringRatchet.stringToUint8Array(chunk);
-                }
-                else {
-                    out.push(chunk);
-                }
-                return null;
-            },
-            abort(reason) {
-                ErrorRatchet.throwFormattedErr('StringWebWritableStream failure : %s', reason);
-            },
-        }, {
-            highWaterMark: 3,
-            size: () => 1,
-        });
-        await stream.pipeTo(writer);
-        return Buffer.concat(out);
-    }
-    static async webReadableStreamToString(stream) {
-        const buf = await StreamRatchet.webReadableStreamToBuffer(stream);
-        return buf.toString();
-    }
-    static stringToReadable(input) {
-        return new Readable({
-            read() {
-                this.push(input);
-                this.push(null);
-            },
-        });
-    }
-    static stringToWebReadableStream(input) {
-        const rval = new ReadableStream({
-            start(controller) {
-                if (input) {
-                    controller.enqueue(input);
-                }
-                controller.close();
-                return null;
-            },
-        }, {
-            highWaterMark: input ? input.length : null,
-        });
-        return rval;
-    }
-    static anyToStringReadable(input) {
-        return input === null || input === undefined
-            ? StreamRatchet.stringToReadable(null)
-            : StreamRatchet.stringToReadable(StringRatchet.safeString(input));
-    }
-}

package/lib/stream/stream-ratchet.spec.js

@@ -1,13 +0,0 @@
-import { StreamRatchet } from './stream-ratchet.js';
-describe('#StreamRatchet', function () {
-    it('should wrap a string in a readable', async () => {
-        const r = StreamRatchet.stringToReadable('test');
-        const out = r.read(200);
-        expect(out.length).toEqual(4);
-    });
-    it('should wrap an number in a readable', async () => {
-        const r = StreamRatchet.anyToStringReadable(401);
-        const out = r.read(200);
-        expect(out.length).toEqual(3);
-    });
-});

package/lib/stream/string-writable.js

@@ -1,14 +0,0 @@
-import { Writable } from 'stream';
-export class StringWritable extends Writable {
-    _val = '';
-    constructor() {
-        super();
-    }
-    _write(chunk, encoding, callback) {
-        this._val += chunk ? chunk.toString() : '';
-        callback();
-    }
-    get value() {
-        return this._val;
-    }
-}

package/lib/stream/string-writable.spec.js

@@ -1,12 +0,0 @@
-import { StringWritable } from './string-writable.js';
-describe('#StringWritable', function () {
-    it('should write cumulatively to a string', async () => {
-        const sr = new StringWritable();
-        const callback = () => {
-        };
-        sr._write('a', null, callback);
-        sr._write('b', null, callback);
-        sr._write('c', null, callback);
-        expect(sr.value.length).toEqual(3);
-    });
-});

package/lib/third-party/google/google-recaptcha-ratchet.js

@@ -1,28 +0,0 @@
-import { Logger } from '../../logger/logger.js';
-import { StringRatchet } from '../../lang/string-ratchet.js';
-import fetch from 'cross-fetch';
-export class GoogleRecaptchaRatchet {
-    static GOOGLE_VERIFY_URL = 'https://www.google.com/recaptcha/api/siteverify?secret={{KEY}}&response={{TOKEN}}';
-    static async verifyRecaptchaToken(keySecret, token, fetchFn = fetch) {
-        Logger.debug('Verifying recaptcha token : %s', token);
-        let rval = null;
-        if (!StringRatchet.safeString(token)) {
-            Logger.warn('Recaptcha validation error, no token passed : %s', token);
-            return rval;
-        }
-        Logger.info('Validating Recaptcha via Google API : %s', token);
-        let url = GoogleRecaptchaRatchet.GOOGLE_VERIFY_URL;
-        url = url.split('{{KEY}}').join(keySecret);
-        url = url.split('{{TOKEN}}').join(token);
-        try {
-            const resp = await fetchFn(url);
-            const body = await resp.json();
-            rval = body && body.success;
-        }
-        catch (err) {
-            Logger.error('Failed to read from google : %s', err);
-            rval = false;
-        }
-        return rval;
-    }
-}

package/lib/third-party/google/google-recaptcha-ratchet.spec.js

@@ -1,20 +0,0 @@
-import { GoogleRecaptchaRatchet } from './google-recaptcha-ratchet.js';
-import { jest } from '@jest/globals';
-const fakeFetch = jest.fn((input, init) => Promise.resolve({
-    json: () => Promise.resolve({ success: true }),
-}));
-const fakeFailFetch = jest.fn((input, init) => Promise.reject('Failed to read'));
-describe('#googleRecaptchaService', () => {
-    it('should validate a recaptcha token', async () => {
-        const res = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', 'anytoken', fakeFetch);
-        expect(res).toBeTruthy();
-    });
-    it('should fail with no token', async () => {
-        const res = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', null, fakeFetch);
-        expect(res).toBeFalsy();
-    });
-    it('should fail if http fails', async () => {
-        const res = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', 'anytoken', fakeFailFetch);
-        expect(res).toBeFalsy();
-    });
-});

package/lib/third-party/twilio/twilio-ratchet.js

@@ -1,73 +0,0 @@
-import fetch from 'cross-fetch';
-import { RequireRatchet } from '../../lang/require-ratchet.js';
-import { Base64Ratchet } from '../../lang/base64-ratchet.js';
-import { StringRatchet } from '../../lang/string-ratchet.js';
-import { Logger } from '../../logger/logger.js';
-export class TwilioRatchet {
-    accountSid;
-    authToken;
-    outBoundNumber;
-    static TWILLIO_BASE_API_URL = 'https://api.twilio.com/2010-04-01';
-    constructor(accountSid, authToken, outBoundNumber) {
-        this.accountSid = accountSid;
-        this.authToken = authToken;
-        this.outBoundNumber = outBoundNumber;
-        RequireRatchet.notNullOrUndefined(accountSid, 'accountSid');
-        RequireRatchet.notNullOrUndefined(authToken, 'authToken');
-        RequireRatchet.notNullOrUndefined(outBoundNumber, 'outBoundNumber');
-        RequireRatchet.true(TwilioRatchet.isValidE164Number(outBoundNumber), 'outBoundNumber invalid format');
-    }
-    static async sendMessageDirect(accountSid, authToken, outBoundNumber, recipientPhoneNumbers, message) {
-        const ratchet = new TwilioRatchet(accountSid, authToken, outBoundNumber);
-        const rval = await ratchet.sendMessage(recipientPhoneNumbers, message);
-        return rval;
-    }
-    static generateTwilioBasicAuth(sid, authToken) {
-        const authHeader = 'Basic ' + Base64Ratchet.generateBase64VersionOfString(sid + ':' + authToken);
-        return authHeader;
-    }
-    async sendMessage(recipientPhoneNumbers, message) {
-        const rval = [];
-        RequireRatchet.notNullOrUndefined(recipientPhoneNumbers, 'recipientPhoneNumbers');
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(message), 'message');
-        RequireRatchet.true(recipientPhoneNumbers.length > 0, 'recipientPhoneNumbers non-empty');
-        recipientPhoneNumbers.forEach((p) => {
-            RequireRatchet.true(TwilioRatchet.isValidE164Number(p), p + ' is not valid');
-        });
-        if (!!recipientPhoneNumbers && recipientPhoneNumbers.length > 0 && !!StringRatchet.trimToNull(message)) {
-            Logger.info('Sending %s to %j', message, recipientPhoneNumbers);
-            for (let i = 0; i < recipientPhoneNumbers.length; i++) {
-                const phoneNumber = recipientPhoneNumbers[i];
-                Logger.info('To: %s', phoneNumber);
-                if (!TwilioRatchet.isValidE164Number(phoneNumber)) {
-                    throw new Error('number must be E164 format!');
-                }
-                const body = 'Body=' +
-                    encodeURIComponent(message) +
-                    '&From=' +
-                    encodeURIComponent(this.outBoundNumber) +
-                    '&To=' +
-                    encodeURIComponent(phoneNumber);
-                const post = {
-                    method: 'post',
-                    headers: {
-                        authorization: TwilioRatchet.generateTwilioBasicAuth(this.accountSid, this.authToken),
-                        'Content-Type': 'application/x-www-form-urlencoded',
-                    },
-                    body: body,
-                };
-                const res = await fetch(TwilioRatchet.TWILLIO_BASE_API_URL + '/Accounts/' + this.accountSid + '/Messages.json', post);
-                const parsedResponse = await res.json();
-                Logger.debug('TwilioRatchet: For %s got %j', phoneNumber, parsedResponse);
-                rval.push(parsedResponse);
-            }
-        }
-        else {
-            Logger.warn('Not sending empty message / empty recipients');
-        }
-        return rval;
-    }
-    static isValidE164Number(num) {
-        return /^\+?[1-9]\d{1,14}$/.test(num);
-    }
-}

package/lib/transform/built-in-transforms.js

@@ -1,191 +0,0 @@
-import { Logger } from '../logger/logger.js';
-import { NumberRatchet } from '../lang/number-ratchet.js';
-import { DateTime } from 'luxon';
-export class BuiltInTransforms {
-    static keysOnly(rule) {
-        return {
-            transform(value, isKey, context) {
-                return isKey ? rule.transform(value, isKey, context) : value;
-            },
-        };
-    }
-    static valuesOnly(rule) {
-        return {
-            transform(value, isKey, context) {
-                return !isKey ? rule.transform(value, isKey, context) : value;
-            },
-        };
-    }
-    static stringReplaceTransform(input, output) {
-        return {
-            transform(value, isKey, context) {
-                return value == input ? output : value;
-            },
-        };
-    }
-    static stripStringTransform(input) {
-        return {
-            transform(value, isKey, context) {
-                return value == input ? null : value;
-            },
-        };
-    }
-    static retainAll(input) {
-        return {
-            transform(value, isKey, context) {
-                return input.indexOf(value) == -1 ? null : value;
-            },
-        };
-    }
-    static removeAll(input) {
-        return {
-            transform(value, isKey, context) {
-                return input.indexOf(value) > -1 ? null : value;
-            },
-        };
-    }
-    static snakeToCamelCase() {
-        return {
-            transform(value, isKey, context) {
-                let rval = value;
-                if (typeof value == 'string') {
-                    rval = value.replace(/_([a-z0-9])/gi, function (s, group1) {
-                        return group1.toUpperCase();
-                    });
-                }
-                return rval;
-            },
-        };
-    }
-    static stringToNumber() {
-        return {
-            transform(value, isKey, context) {
-                let rval = value;
-                if (typeof value == 'string') {
-                    const num = NumberRatchet.safeNumber(value);
-                    if (num !== null) {
-                        rval = num;
-                    }
-                }
-                return rval;
-            },
-        };
-    }
-    static camelToSnakeCase() {
-        return {
-            transform(value, isKey, context) {
-                let rval = value;
-                if (typeof value == 'string') {
-                    rval = value
-                        .replace(/\.?([A-Z]+)/g, function (x, y) {
-                        return '_' + y.toLowerCase();
-                    })
-                        .replace(/^_/, '');
-                }
-                return rval;
-            },
-        };
-    }
-    static concatenateToNewField(newFieldName, oldFieldNamesInOrder, abortIfFieldMissing = true) {
-        return {
-            transform(value, isKey, context) {
-                if (typeof value == 'object') {
-                    let rval = '';
-                    oldFieldNamesInOrder.forEach((n) => {
-                        if (rval != null) {
-                            const temp = value[n];
-                            if (temp == null && abortIfFieldMissing) {
-                                rval = null;
-                            }
-                            else {
-                                rval = temp == null ? rval : rval + String(temp);
-                            }
-                        }
-                    });
-                    if (rval != null) {
-                        value[newFieldName] = rval;
-                        oldFieldNamesInOrder.forEach((n) => delete value[n]);
-                    }
-                }
-                return value;
-            },
-        };
-    }
-    static numberToBool(fieldNames) {
-        return {
-            transform(value, isKey, context) {
-                if (typeof value == 'object') {
-                    fieldNames.forEach((n) => {
-                        const oldVal = value[n];
-                        if (typeof oldVal == 'number') {
-                            const newVal = 0 != oldVal;
-                            value[n] = newVal;
-                        }
-                    });
-                }
-                return value;
-            },
-        };
-    }
-    static boolToNumber(fieldNames) {
-        return {
-            transform(value, isKey, context) {
-                if (typeof value == 'object') {
-                    fieldNames.forEach((n) => {
-                        const oldVal = value[n];
-                        if (typeof oldVal == 'boolean') {
-                            const newVal = oldVal ? 1 : 0;
-                            value[n] = newVal;
-                        }
-                    });
-                }
-                return value;
-            },
-        };
-    }
-    static makeDuplicateField(oldName, newName) {
-        return {
-            transform(value, isKey, context) {
-                if (typeof value == 'object') {
-                    const oldVal = value[oldName];
-                    if (oldVal != null) {
-                        value[newName] = oldVal;
-                    }
-                }
-                return value;
-            },
-        };
-    }
-    static addField(name, valueToAdd) {
-        return {
-            transform(value, isKey, context) {
-                if (typeof value == 'object') {
-                    value[name] = valueToAdd;
-                }
-                return value;
-            },
-        };
-    }
-    static reformatDateFields(fieldNames, oldFormat, newFormat) {
-        return {
-            transform(value, isKey, context) {
-                if (typeof value == 'object') {
-                    fieldNames.forEach((key) => {
-                        const oldValue = value[key];
-                        if (oldValue != null) {
-                            try {
-                                const parsed = DateTime.fromFormat(oldValue, oldFormat);
-                                const newValue = parsed.toFormat(newFormat);
-                                value[key] = newValue;
-                            }
-                            catch (err) {
-                                Logger.warn('Failed to reparse date %s in format %s : %s', oldValue, oldFormat, err);
-                            }
-                        }
-                    });
-                }
-                return value;
-            },
-        };
-    }
-}

package/lib/transform/transform-rule.js

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

package/lib/tx/transaction-configuration.js

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

package/lib/tx/transaction-final-state.js

@@ -1,6 +0,0 @@
-export var TransactionFinalState;
-(function (TransactionFinalState) {
-    TransactionFinalState["Success"] = "Success";
-    TransactionFinalState["RolledBack"] = "RolledBack";
-    TransactionFinalState["RollbackFailed"] = "RollbackFailed";
-})(TransactionFinalState || (TransactionFinalState = {}));