@stinkycomputing/cachearoo 1.0.24

package/dist/libs/cro.connection.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentConnection = void 0;
+const util_1 = require("util");
+const websocket_1 = require("websocket");
+const cro_1 = require("./cro");
+const REQUEST_TIMEOUT = 3000;
+function headerToBuffer(header) {
+    const buf = new Uint8Array(128);
+    let offset = 0;
+    const Encoder = (typeof window !== 'undefined') ? window.TextEncoder : util_1.TextEncoder;
+    const encoder = new Encoder();
+    const bucket = encoder.encode(header.bucket);
+    const key = encoder.encode(header.key);
+    const apiKey = encoder.encode(header.apiKey);
+    if ((bucket.byteLength > 36) || (key.byteLength > 36) || (apiKey.byteLength > 36)) {
+        throw new Error('Cannot write binary header, bucket/key/apiKey cannot exceed 36 bytes each');
+    }
+    buf[0] = header.type;
+    buf[1] = bucket.byteLength;
+    buf[2] = key.byteLength;
+    buf[3] = apiKey.byteLength;
+    offset = 4;
+    buf.set(bucket, offset);
+    offset += buf[1];
+    buf.set(key, offset);
+    offset += buf[2];
+    buf.set(apiKey, offset);
+    return buf;
+}
+function bufferToHeader(buffer) {
+    let bucketSize = buffer[1];
+    let keySize = buffer[2];
+    let apiKeySize = buffer[3];
+    const Decoder = (typeof window !== 'undefined') ? window.TextDecoder : util_1.TextDecoder;
+    const decoder = new Decoder('utf-8');
+    const res = {
+        type: buffer[0],
+        bucket: '',
+        key: '',
+        apiKey: '',
+    };
+    let offset = 4;
+    res.bucket = decoder.decode(buffer.slice(offset, offset + bucketSize));
+    offset = offset + bucketSize;
+    res.key = decoder.decode(buffer.slice(offset, offset + keySize));
+    offset = offset + keySize;
+    res.apiKey = decoder.decode(buffer.slice(offset, offset + apiKeySize));
+    return res;
+}
+class PersistentConnection {
+    onConnect;
+    onDisconnect;
+    onError;
+    onPong;
+    connected = false;
+    id = undefined;
+    enablePing = false;
+    settings;
+    requestID = 0;
+    events = [];
+    binaryEvents = [];
+    sendValues = false;
+    ws = undefined;
+    eventsReceived = 0;
+    skipReconnect = false;
+    requests = [];
+    requestTimer = undefined;
+    reconnectTimer = undefined;
+    pingTimer = undefined;
+    pingInterval = 5000;
+    apiKey;
+    async request(options) {
+        if (!options.key)
+            options.key = '';
+        const bucket = options.bucket || this.settings.bucket || '';
+        const method = options.method || 'GET';
+        if ((method === 'GET') && (options.key === '')) {
+            return this.list(bucket, options.keysOnly, options.filter);
+        }
+        else if (method === 'GET') {
+            return this.read(bucket, options.key);
+        }
+        else if ((method === 'POST') || (method === 'PUT')) {
+            return this.write(bucket, options.key, options.data, options.failIfExists, options.expire);
+        }
+        else if (method === 'DELETE') {
+            return this.delete(bucket, options.key);
+        }
+        else if (method === 'PATCH') {
+            return this.patch(bucket, options.key, options.data, options.removeDataFromReply);
+        }
+        else if (method === 'EVENT') {
+            return this.signalEvent(bucket, options.key, options.data);
+        }
+    }
+    ;
+    constructor(settings) {
+        this.settings = settings;
+        this.enablePing = !!settings.enablePing;
+        this.pingInterval = settings.pingInterval || this.pingInterval;
+        var protocol = (settings.secure) ? 'wss://' : 'ws://';
+        this.apiKey = settings.apiKey;
+        const subDomain = settings.wsSubDomain ? settings.wsSubDomain + '.' : '';
+        const url = protocol + subDomain + settings.host + ':' + settings.port + settings.path + '?id=' + settings.clientId + "&apiKey=" + (settings.apiKey || '');
+        this.wsStart(url);
+        this.checkRequestTimeouts();
+    }
+    async read(bucket, key) {
+        return new Promise((resolve, reject) => {
+            this.addRequest({ op: 'read', bucket: bucket, key: key }, function (err, obj) {
+                if (err) {
+                    reject(new Error('Cachearoo ws READ error: ' + JSON.stringify(err) + ' for bucket: ' + bucket + ', key: ' + key));
+                }
+                else {
+                    resolve(obj);
+                }
+            });
+        });
+    }
+    ;
+    async list(bucket, keysOnly, filter) {
+        return new Promise((resolve, reject) => {
+            this.addRequest({ op: 'filter', bucket: bucket, keysOnly: keysOnly, filter: filter }, function (err, location) {
+                if (err) {
+                    reject(new Error('Cachearoo ws FILTER error: ' + JSON.stringify(err) + ' for bucket: ' + bucket));
+                }
+                else {
+                    resolve(location);
+                }
+            });
+        });
+    }
+    async write(bucket, key, value, failIfExists, expire) {
+        return new Promise((resolve, reject) => {
+            this.addRequest({ op: 'write', bucket: bucket, key: key, value: value, failIfExists: failIfExists, expire: expire }, function (err, location) {
+                if (err) {
+                    const error = ((err.alreadyExists) ? new cro_1.AlreadyExistsError(`Key ${key} already exists`) :
+                        new Error('Cachearoo ws WRITE error: ' + JSON.stringify(err) + ' for bucket: ' + bucket + ', key: ' + key));
+                    reject(error);
+                }
+                else {
+                    resolve(location);
+                }
+            });
+        });
+    }
+    ;
+    async patch(bucket, key, patch, removeDataFromReply) {
+        return new Promise((resolve, reject) => {
+            this.addRequest({ op: 'patch', bucket, key, patch, removeDataFromReply }, function (err, result) {
+                if (err) {
+                    reject(new Error('Cachearoo ws PATCH error: ' + JSON.stringify(err) + ' for bucket: ' + bucket + ', key: ' + key));
+                }
+                else {
+                    resolve(result);
+                }
+            });
+        });
+    }
+    ;
+    async delete(bucket, key) {
+        return new Promise((resolve, reject) => {
+            this.addRequest({ op: 'remove', bucket: bucket, key: key }, function (err) {
+                if (err) {
+                    reject(new Error('Cachearoo ws REMOVE error: ' + JSON.stringify(err) + ' for bucket: ' + bucket + ', key: ' + key));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    ;
+    async signalEvent(bucket, key, value) {
+        var eventObj = { bucket: bucket, key: key, value: value };
+        if ((this.connected) && (this.ws)) {
+            this.ws.send(JSON.stringify({ msg: 'event-broadcast', apiKey: this.apiKey, event: eventObj }));
+            return Promise.resolve();
+        }
+        return Promise.reject(new Error('Cannot call SignalEvent when disconnected'));
+    }
+    ;
+    async signalEventBinary(type, bucket, key, value) {
+        const header = {
+            type,
+            bucket,
+            key,
+            apiKey: this.apiKey || '',
+        };
+        const data = headerToBuffer(header);
+        if ((this.connected) && (this.ws)) {
+            this.ws.send(Buffer.concat([data, value]));
+        }
+    }
+    close() {
+        this.events = [];
+        this.skipReconnect = true;
+        this.connected = false;
+        if ((this.ws) && (this.ws.close)) {
+            this.ws.close();
+        }
+        this.ws = undefined;
+        clearTimeout(this.reconnectTimer);
+        clearInterval(this.pingTimer);
+        clearTimeout(this.requestTimer);
+    }
+    ;
+    addListenerBinary(bucket, key, callback) {
+        if ((callback == null) || (typeof callback != 'function'))
+            throw 'Callback is not a function';
+        this.binaryEvents.push({
+            bucket: bucket,
+            key: key,
+            callback: callback
+        });
+        this.registerEvents();
+    }
+    ;
+    addListener(bucket, key, sendValues, callback) {
+        if ((callback == null) || (typeof callback != 'function'))
+            throw 'Callback is not a function';
+        if (sendValues)
+            this.sendValues = true;
+        this.events.push({
+            bucket: bucket,
+            key: key,
+            callback: callback
+        });
+        this.registerEvents();
+    }
+    ;
+    removeListener(callback) {
+        this.events = this.events.filter(item => item.callback !== callback);
+        this.binaryEvents = this.binaryEvents.filter(item => item.callback !== callback);
+        this.registerEvents();
+    }
+    removeAllListeners() {
+        this.events = [];
+        this.binaryEvents = [];
+    }
+    addRequest(obj, callback) {
+        this.requestID = this.requestID + 1;
+        this.requests[this.requestID] = { timeStamp: new Date(), callback: callback };
+        obj.id = this.requestID + '';
+        if ((this.connected) && (this.ws)) {
+            this.ws.send(JSON.stringify({ msg: 'datastore-operation', apiKey: this.apiKey, request: obj }));
+        }
+    }
+    ;
+    handleReponse(response) {
+        if (this.requests[response.id]) {
+            this.requests[response.id].callback(response.error, response.value || response.location);
+            this.requests[response.id] = null;
+        }
+    }
+    ;
+    checkRequestTimeouts() {
+        this.requestTimer = setTimeout(() => {
+            for (var i in this.requests) {
+                var req = this.requests[i + ''];
+                if (req) {
+                    var now = new Date().getTime();
+                    if (now - this.requests[i].timeStamp > REQUEST_TIMEOUT) {
+                        req.callback('Timeout occured for request ' + req.id);
+                        this.requests[i] = null;
+                    }
+                }
+            }
+            if (!this.skipReconnect)
+                this.checkRequestTimeouts();
+        }, 1000);
+    }
+    ;
+    registerEvents() {
+        if (this.connected) {
+            var eventMap = [];
+            var eventArr = [];
+            const events = [...this.events, ...this.binaryEvents];
+            for (var i = 0; i < events.length; i++) {
+                var eventJson = JSON.stringify(events[i]);
+                if (!eventMap[eventJson]) {
+                    eventArr.push({
+                        bucket: events[i].bucket,
+                        key: events[i].key
+                    });
+                    eventMap[eventJson] = true;
+                }
+            }
+            this.ws?.send(JSON.stringify({
+                msg: 'register-events',
+                events: eventArr,
+                sendValues: this.sendValues,
+                apiKey: this.apiKey
+            }));
+        }
+    }
+    ;
+    processBinaryMessage(data) {
+        if (data.byteLength < 128)
+            return console.error('Binary data without header');
+        const header = bufferToHeader(new Uint8Array(data));
+        for (var i = 0; i < this.binaryEvents.length; i++) {
+            if (((this.binaryEvents[i].bucket === '*') || (this.binaryEvents[i].bucket == header.bucket)) &&
+                ((this.binaryEvents[i].key === '*') || (this.binaryEvents[i].key == header.key))) {
+                this.binaryEvents[i].callback({
+                    type: header.type,
+                    bucket: header.bucket,
+                    key: header.key,
+                    content: data.slice(128),
+                });
+            }
+        }
+    }
+    processStringMessage(message) {
+        var eventObj = JSON.parse(message);
+        if (eventObj.id) {
+            this.id = eventObj.id;
+            if (typeof this.onConnect === 'function') {
+                this.onConnect(this);
+            }
+            return;
+        }
+        if (eventObj.response) {
+            this.handleReponse(eventObj.response);
+            return;
+        }
+        if (eventObj.pong) {
+            if (typeof this.onPong === 'function') {
+                this.onPong();
+            }
+            return;
+        }
+        this.eventsReceived++;
+        var value = ((typeof eventObj.value !== 'undefined') && (typeof eventObj.isDeleted === 'undefined')) ? eventObj.value : null;
+        var obj = {
+            bucket: eventObj.bucket,
+            key: eventObj.key,
+            value: value,
+            isDeleted: undefined
+        };
+        if (eventObj.isDeleted)
+            obj.isDeleted = true;
+        for (var i = 0; i < this.events.length; i++) {
+            if (((this.events[i].bucket === '*') || (this.events[i].bucket == obj.bucket)) &&
+                ((this.events[i].key === '*') || (this.events[i].key == obj.key))) {
+                this.events[i].callback(obj);
+            }
+        }
+    }
+    wsStart(url) {
+        this.skipReconnect = false;
+        this.connected = false;
+        if (this.pingTimer)
+            clearInterval(this.pingTimer);
+        if ((this.ws) && (this.ws.close))
+            this.ws.close();
+        this.ws = new websocket_1.w3cwebsocket(url, '', undefined, undefined, undefined, { maxReceivedMessageSize: 128 * 1024 * 1024 });
+        this.ws.binaryType = 'arraybuffer';
+        if (this.enablePing) {
+            this.pingTimer = setInterval(() => {
+                if ((this.ws != null) && (this.connected)) {
+                    this.ws.send(JSON.stringify({ msg: 'ping' }));
+                }
+            }, this.pingInterval);
+        }
+        this.ws.onerror = (error) => {
+            if (typeof this.onError === 'function')
+                this.onError(error);
+        };
+        this.ws.onmessage = (message) => {
+            if (typeof message.data === 'string') {
+                this.processStringMessage(message.data);
+            }
+            else {
+                this.processBinaryMessage(message.data);
+            }
+        };
+        this.ws.onclose = () => {
+            if (this.connected) {
+                this.connected = false;
+                if (typeof this.onDisconnect === 'function') {
+                    this.onDisconnect(this);
+                }
+            }
+            if (!this.skipReconnect) {
+                this.reconnectTimer = setTimeout(() => {
+                    if (!this.skipReconnect) {
+                        this.wsStart(url);
+                    }
+                }, 3000);
+            }
+            ;
+        };
+        this.ws.onopen = () => {
+            this.connected = true;
+            this.registerEvents();
+        };
+    }
+}
+exports.PersistentConnection = PersistentConnection;

package/dist/libs/cro.d.ts

@@ -0,0 +1,82 @@
+import { PersistentConnection } from './cro.connection';
+export declare class TimeoutError extends Error {
+    progressTimeout: boolean;
+    constructor(message: any, progressTimeout: any);
+}
+export declare class AlreadyExistsError extends Error {
+    constructor(message: any);
+}
+export declare function generateUUID(): string;
+export interface ICachearooSettings {
+    bucket?: string;
+    host?: string;
+    port?: number;
+    path?: string;
+    apiKey?: string;
+    secure?: boolean;
+    enablePing?: boolean;
+    pingInterval?: number;
+    clientId?: string;
+    wsSubDomain?: string;
+}
+export declare class CachearooSettings {
+    bucket?: string;
+    host?: string;
+    port?: number;
+    path: string;
+    apiKey?: string;
+    secure: boolean;
+    enablePing: boolean;
+    pingInterval: number;
+    clientId?: string;
+    wsSubDomain?: string;
+}
+export declare class RequestOptions {
+    bucket?: string;
+    data?: string;
+    failIfExists: boolean;
+    expire?: string;
+    async: boolean;
+    forceHttp: boolean;
+    keysOnly: boolean;
+    filter?: string;
+    removeDataFromReply: boolean;
+    constructor(options: any);
+}
+export declare class RequestOptionsInternal extends RequestOptions {
+    url?: string;
+    method?: string;
+    key?: string;
+    forceHttp: boolean;
+    keysOnly: boolean;
+    filter?: string;
+    removeDataFromReply: boolean;
+    isList: boolean;
+}
+export interface IListReplyItem {
+    key: string;
+    timestamp: string;
+    size: number;
+    expire?: Date;
+    content?: object;
+}
+export declare class Cachearoo {
+    connection: PersistentConnection;
+    private settings;
+    private requestQueue;
+    private pendingRequests;
+    private internalizeRequestOptions;
+    private checkOptions;
+    read(key: string, options?: RequestOptions): Promise<unknown>;
+    list(options?: RequestOptions): Promise<IListReplyItem[]>;
+    write(key: string, value: any, options?: RequestOptions): Promise<unknown>;
+    patch(key: string, patch: string, options?: RequestOptions): Promise<unknown>;
+    remove(key: string, options?: RequestOptions): Promise<unknown>;
+    repair(bucket: string): Promise<any>;
+    private getUrl;
+    private requestHttp;
+    private request;
+    private processRequestQueue;
+    close(): void;
+    constructor(settings?: ICachearooSettings);
+}