dequanto 0.0.1

package/dist/src/json/JsonArrayStore.js

@@ -0,0 +1,296 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonArrayStore = void 0;
+const atma_io_1 = require("atma-io");
+const atma_utils_1 = require("atma-utils");
+const memd_1 = __importDefault(require("memd"));
+const alot_1 = __importDefault(require("alot"));
+const class_json_1 = require("class-json");
+class JsonArrayStore {
+    constructor(options) {
+        this.options = options;
+        this.fs = new JsonArrayFs(this.options.path, this.options.Type, this.options.map, this.options.format);
+        let keyFn = this.options.key;
+        if (keyFn == null) {
+            throw new Error('Key getter must be defined');
+        }
+    }
+    async query() {
+        let arr = await this.getAll();
+        return (0, alot_1.default)(arr);
+    }
+    async getAll(opts) {
+        if (this.fs.errored != null) {
+            throw this.fs.errored;
+        }
+        if (this.array == null) {
+            await this.restore();
+        }
+        let arr = this.array;
+        if (opts?.cloned) {
+            arr = class_json_1.JsonConvert.fromJSON(class_json_1.JsonConvert.toJSON(arr));
+        }
+        return arr;
+    }
+    async getDict() {
+        if (this.fs.errored != null) {
+            throw this.fs.errored;
+        }
+        if (this.hash != null) {
+            return this.hash;
+        }
+        await this.restore();
+        return this.hash;
+    }
+    async getSingle(key) {
+        if (this.fs.errored != null) {
+            throw this.fs.errored;
+        }
+        if (this.hash == null) {
+            await this.restore();
+        }
+        return this.hash[String(key)];
+    }
+    async saveAll(arr) {
+        let keyFn = this.options.key;
+        this.array = arr;
+        this.hash = (0, alot_1.default)(arr).toDictionary(x => String(keyFn(x)), x => x);
+        await this.fs.write(arr);
+        return arr;
+    }
+    async upsert(x) {
+        if (this.hash == null) {
+            await this.restore();
+        }
+        let entry = this.upsertSync(x);
+        await this.flush();
+        return entry;
+    }
+    async remove(key) {
+        if (this.hash == null) {
+            await this.restore();
+        }
+        let entry = this.removeSync(key);
+        await this.flush();
+        return entry;
+    }
+    async upsertMany(arr) {
+        if (this.hash == null) {
+            await this.restore();
+        }
+        let entries = arr.map(x => this.upsertSync(x));
+        await this.flush();
+        return entries;
+    }
+    getLock() {
+        return this.fs.lock;
+    }
+    async restore() {
+        let arr = await this.fs.read();
+        let keyFn = this.options.key;
+        if (this.array != null) {
+            // write was called inbetween
+            return;
+        }
+        this.array = arr;
+        this.hash = (0, alot_1.default)(arr).toDictionary(x => String(keyFn(x)), x => x);
+    }
+    async flush() {
+        return await this.fs.write(this.array);
+    }
+    /** without flush */
+    upsertSync(x) {
+        let keyFn = this.options.key;
+        let key = String(keyFn(x));
+        if (key == null) {
+            throw new Error(`Key is undefined in ${JSON.stringify(x)}`);
+        }
+        let current = this.hash[key];
+        if (current) {
+            for (let prop in x) {
+                current[prop] = x[prop];
+            }
+            return current;
+        }
+        let entry = x;
+        let Type = this.options.Type;
+        if (Type != null && entry instanceof Type === false) {
+            entry = new Type(x);
+        }
+        this.array.push(entry);
+        this.hash[key] = entry;
+        return entry;
+    }
+    removeSync(key) {
+        let current = this.hash[key];
+        if (current == null) {
+            return null;
+        }
+        delete this.hash[key];
+        let i = this.array.indexOf(current);
+        if (i > -1) {
+            this.array.splice(i, 1);
+        }
+        return current;
+    }
+}
+exports.JsonArrayStore = JsonArrayStore;
+class JsonArrayFs {
+    constructor(path, Type, mapFn, format) {
+        this.path = path;
+        this.Type = Type;
+        this.mapFn = mapFn;
+        this.format = format;
+        this.errored = null;
+        this.listeners = [];
+        this.version = 0;
+        this.busy = false;
+        this.pathBak = this.path + '.bak';
+        this.pathFilename = this.path.substring(this.path.lastIndexOf('/') + 1);
+        this.lock = new atma_utils_1.class_Dfr;
+        this.lock.resolve();
+    }
+    write(arr) {
+        this.array = arr;
+        let dfr = new atma_utils_1.class_Dfr;
+        this.listeners.push({
+            version: ++this.version,
+            promise: dfr
+        });
+        if (this.busy === true) {
+            this.pending = arr;
+            return dfr;
+        }
+        this.busy = true;
+        this.lock.defer();
+        this.writeInner(arr);
+        return dfr;
+    }
+    async read() {
+        if (this.array != null) {
+            return Promise.resolve(this.array);
+        }
+        let arr = await this.readInner();
+        return this.array = arr;
+    }
+    async readInner() {
+        let existsBak = await atma_io_1.File.existsAsync(this.pathBak);
+        if (existsBak) {
+            let arr = await Fs.read(this.pathBak);
+            if (this.array) {
+                // When `write` was called inbetween `exists` check and now
+                return this.array;
+            }
+            if (arr) {
+                await atma_io_1.File.renameAsync(this.pathBak, this.pathFilename);
+                return arr;
+            }
+            else {
+                await atma_io_1.File.removeAsync(this.pathBak);
+            }
+        }
+        let exists = await atma_io_1.File.existsAsync(this.path);
+        if (exists === false) {
+            return [];
+        }
+        if (!this.path) {
+            throw new Error(`Read inner: ${this.path}/${this.pathBak} is undefined`);
+        }
+        let arr = await atma_io_1.File.readAsync(this.path);
+        if (this.Type) {
+            let rgx = Math.round(Math.random() * 100000);
+            let key = `JsonArray.Type ${rgx}`;
+            console.time(key);
+            arr = arr.map(x => class_json_1.JsonConvert.fromJSON(x, { Type: this.Type }));
+            console.timeEnd(key);
+        }
+        if (this.mapFn) {
+            arr = arr.map(this.mapFn);
+        }
+        return arr;
+    }
+    async writeInner(arr) {
+        try {
+            let v = this.version;
+            let data = Fs.serialize(arr, this.Type, this.format);
+            await atma_io_1.File.writeAsync(this.pathBak, data);
+            await atma_io_1.File.renameAsync(this.pathBak, this.pathFilename);
+            this.callWriteListeners(v, null);
+        }
+        catch (error) {
+            console.error(`JsonArrayStore.WriteInner`, error);
+            this.errored = error;
+        }
+        finally {
+            if (this.pending == null) {
+                this.busy = false;
+                this.lock.resolve();
+                return;
+            }
+            let next = this.pending;
+            this.pending = null;
+            this.writeInner(next);
+        }
+    }
+    callWriteListeners(v, error = null) {
+        for (let i = 0; i < this.listeners.length; i++) {
+            let x = this.listeners[i];
+            if (x.version <= v) {
+                try {
+                    if (error != null) {
+                        x.promise.reject(error);
+                    }
+                    else {
+                        x.promise.resolve();
+                    }
+                }
+                finally {
+                    this.listeners.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], JsonArrayFs.prototype, "readInner", null);
+var Fs;
+(function (Fs) {
+    function serialize(arr, Type, format) {
+        if (Type) {
+            arr = arr.map(x => class_json_1.JsonConvert.toJSON(x));
+        }
+        return JSON.stringify(arr, null, format ? '  ' : null);
+    }
+    Fs.serialize = serialize;
+    function parse(str) {
+        return JSON.parse(str);
+    }
+    Fs.parse = parse;
+    async function read(path) {
+        if (!path) {
+            throw new Error(`${path} is undefined`);
+        }
+        let str = await atma_io_1.File.readAsync(path, { skipHooks: true, encoding: 'utf8' });
+        if (str.length === 0) {
+            return null;
+        }
+        try {
+            return JSON.parse(str);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    Fs.read = read;
+})(Fs || (Fs = {}));

package/dist/src/json/JsonObjectStore.js

@@ -0,0 +1,214 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonObjectStore = void 0;
+const memd_1 = __importDefault(require("memd"));
+const atma_io_1 = require("atma-io");
+const atma_utils_1 = require("atma-utils");
+const class_json_1 = require("class-json");
+const _csv_1 = require("@dequanto/utils/$csv");
+class JsonObjectStore {
+    constructor(options) {
+        this.options = options;
+        this.fs = new JsonFs(this.options.path, this.options.Type, this.options.map, this.options.format);
+    }
+    async get(opts) {
+        if (this.fs.errored != null) {
+            throw this.fs.errored;
+        }
+        if (this.data == null) {
+            await this.restore();
+        }
+        let arr = this.data;
+        if (opts?.cloned) {
+            arr = class_json_1.JsonConvert.fromJSON(class_json_1.JsonConvert.toJSON(arr));
+        }
+        return arr;
+    }
+    async save(arr) {
+        this.data = arr;
+        await this.fs.write(arr);
+        return arr;
+    }
+    getLock() {
+        return this.fs.lock;
+    }
+    async restore() {
+        let data = await this.fs.read(this.options.default);
+        if (this.data != null) {
+            // write was called inbetween
+            return;
+        }
+        this.data = data;
+    }
+    async flush() {
+        return await this.fs.write(this.data);
+    }
+}
+exports.JsonObjectStore = JsonObjectStore;
+class JsonFs {
+    constructor(path, Type, mapFn, format) {
+        this.path = path;
+        this.Type = Type;
+        this.mapFn = mapFn;
+        this.format = format;
+        this.errored = null;
+        this.listeners = [];
+        this.version = 0;
+        this.busy = false;
+        // private pathBak = this.path + '.bak';
+        // private pathFilename = this.path.substring(this.path.lastIndexOf('/') + 1);
+        this.lock = new atma_utils_1.class_Dfr;
+        this._file = new atma_io_1.File(this.path, { threadSafe: true });
+    }
+    write(value) {
+        this.value = value;
+        let dfr = new atma_utils_1.class_Dfr;
+        this.listeners.push({
+            version: ++this.version,
+            promise: dfr
+        });
+        if (this.busy === true) {
+            this.pending = value;
+            return dfr;
+        }
+        this.busy = true;
+        this.lock.defer();
+        this.writeInner(value);
+        return dfr;
+    }
+    async read($default) {
+        if (this.value != null) {
+            return Promise.resolve(this.value);
+        }
+        let arr = await this.readInner();
+        return this.value = arr ?? $default ?? {};
+    }
+    async readInner() {
+        if (await this._file.existsAsync() === false) {
+            return null;
+        }
+        let str = await this._file.readAsync({ skipHooks: true });
+        let data = JsonUtil.fromString(str, {}, this.Type, this._file.uri.toLocalFile());
+        if (this.mapFn) {
+            data = Array.isArray(data)
+                ? data.map(this.mapFn)
+                : this.mapFn(data);
+        }
+        return data;
+    }
+    async writeInner(value) {
+        try {
+            let v = this.version;
+            let str = JsonUtil.toString(value, this.Type, this.format, this._file.uri.toLocalFile());
+            await this._file.writeAsync(str);
+            this.callWriteListeners(v, null);
+        }
+        catch (error) {
+            console.error(`JsonArrayStore.WriteInner`, error);
+            this.errored = error;
+        }
+        finally {
+            if (this.pending == null) {
+                this.busy = false;
+                this.lock.resolve();
+                return;
+            }
+            let next = this.pending;
+            this.pending = null;
+            this.writeInner(next);
+        }
+    }
+    callWriteListeners(v, error = null) {
+        for (let i = 0; i < this.listeners.length; i++) {
+            let x = this.listeners[i];
+            if (x.version <= v) {
+                try {
+                    if (error != null) {
+                        x.promise.reject(error);
+                    }
+                    else {
+                        x.promise.resolve();
+                    }
+                }
+                finally {
+                    this.listeners.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], JsonFs.prototype, "readInner", null);
+var JsonUtil;
+(function (JsonUtil) {
+    function mapToJson(data, Type) {
+        if (Type == null) {
+            return data;
+        }
+        return Array.isArray(data)
+            ? data.map(x => class_json_1.JsonConvert.toJSON(x, { Type }))
+            : class_json_1.JsonConvert.toJSON(data, { Type });
+    }
+    JsonUtil.mapToJson = mapToJson;
+    function mapFromJson(json, Type) {
+        if (Type == null) {
+            return json;
+        }
+        return Array.isArray(json)
+            ? json.map(x => class_json_1.JsonConvert.fromJSON(x, { Type }))
+            : class_json_1.JsonConvert.fromJSON(json, { Type });
+    }
+    JsonUtil.mapFromJson = mapFromJson;
+    function toString(data, Type, format, path) {
+        if (data == null) {
+            return null;
+        }
+        let json = mapToJson(data, Type);
+        return path.endsWith('.csv')
+            ? CSV.stringify(json)
+            : JSON.stringify(json, null, format ? '  ' : null);
+    }
+    JsonUtil.toString = toString;
+    function fromString(str, $default, Type, path) {
+        if (str == null) {
+            if (Type) {
+                return class_json_1.JsonConvert.fromJSON($default, { Type });
+            }
+            return $default;
+        }
+        try {
+            let json = path.endsWith('.csv')
+                ? CSV.parse(str)
+                : JSON.parse(str);
+            return mapFromJson(json, Type);
+        }
+        catch (err) {
+            return $default;
+        }
+    }
+    JsonUtil.fromString = fromString;
+})(JsonUtil || (JsonUtil = {}));
+var CSV;
+(function (CSV) {
+    function parse(str) {
+        return _csv_1.$csv.parseToRows(str);
+    }
+    CSV.parse = parse;
+    function stringify(rows) {
+        return _csv_1.$csv.stringify({
+            rows: rows
+        });
+    }
+    CSV.stringify = stringify;
+})(CSV || (CSV = {}));

package/dist/src/json/JsonStore.spec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const atma_io_1 = require("atma-io");
+const JsonArrayStore_1 = require("./JsonArrayStore");
+const JsonObjectStore_1 = require("./JsonObjectStore");
+let pathArr = '/test/tmp/jsonstore-arr.json';
+let pathObj = '/test/tmp/jsonstore-obj.json';
+UTest({
+    'array': {
+        $before() {
+            atma_io_1.File.exists(pathArr) && atma_io_1.File.remove(pathArr);
+        },
+        async 'should handle multiple'() {
+            let store = new JsonArrayStore_1.JsonArrayStore({ path: pathArr, key: x => x.id });
+            let tick = Date.now();
+            store.upsert({ id: 1, letter: 'A', tick });
+            store.upsert({ id: 1, letter: 'B' });
+            store.upsert({ id: 1, letter: 'C' });
+            store.upsert({ id: 1, letter: 'D' });
+            await store.upsert({ id: 1, letter: 'E' });
+            let arr = await store.getAll();
+            eq_(arr.length, 1);
+            eq_(arr[0].letter, 'E');
+            eq_(arr[0].tick, tick);
+            store.upsert({ id: 1, letter: 'F' });
+            await store.upsert({ id: 1, letter: 'G' });
+            arr = await store.getAll();
+            eq_(arr.length, 1);
+            eq_(arr[0].letter, 'G');
+            await store.getLock();
+            let existsBak = await atma_io_1.File.existsAsync(pathArr + '.bak');
+            eq_(existsBak, false);
+            let str = await atma_io_1.File.readAsync(pathArr, { skipHooks: true, cache: false });
+            eq_(str[0], '[');
+            let json = JSON.parse(str);
+            deepEq_(json, arr);
+        },
+        'should load file and then write': {
+            async $before() {
+                await atma_io_1.File.writeAsync(pathArr, [
+                    { id: 'foo', letter: 'F' },
+                    { id: 'bar', letter: 'B' }
+                ]);
+                atma_io_1.File.clearCache();
+            },
+            async 'load and upsert'() {
+                let store = new JsonArrayStore_1.JsonArrayStore({
+                    path: pathArr,
+                    key: x => x.id,
+                    map: (x) => {
+                        x.letter = x.letter.toLowerCase();
+                        return x;
+                    }
+                });
+                let all = await store.getAll();
+                let tick = Date.now();
+                eq_(all.length, 2);
+                all[0].tick = tick;
+                all[1].tick = tick;
+                await store.upsertMany(all);
+                atma_io_1.File.clearCache();
+                let arr = await atma_io_1.File.readAsync(pathArr);
+                eq_(arr.length, 2);
+                eq_(arr[0].tick, tick);
+                eq_(arr[0].letter, 'f');
+            }
+        }
+    },
+    'object': {
+        $before() {
+            atma_io_1.File.exists(pathObj) && atma_io_1.File.remove(pathObj);
+        },
+        async 'should handle multiple'() {
+            let store = new JsonObjectStore_1.JsonObjectStore({ path: pathObj });
+            let tick = Date.now();
+            await store.save({ tick });
+            let obj = await store.get();
+            eq_(obj.tick, tick);
+            let obj1 = await atma_io_1.File.readAsync(pathObj, { cache: false });
+            eq_(obj1.tick, tick);
+        },
+    }
+});

package/dist/src/loggers/ILogger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/loggers/LoggerService.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = void 0;
+const everlog_1 = require("everlog");
+class LoggerService {
+    constructor(name = 'journal') {
+        this.name = name;
+        this.channel = everlog_1.Everlog.createChannel(this.name, {
+            directory: './logs/dequanto/',
+            columns: [
+                { type: 'date', name: 'Date' },
+                { type: 'string', name: 'Level' },
+                { type: 'string', name: 'Message' },
+            ]
+        });
+    }
+    warn(message) {
+        this.write([new Date(), 'Warn', message]);
+    }
+    error(message) {
+        this.write([new Date(), 'Error', message]);
+    }
+    info(message) {
+        this.write([new Date(), 'Info', message]);
+    }
+    write(row) {
+        let arr = typeof row === 'string' ? [row] : row;
+        arr.unshift(new Date());
+        this.channel.writeRow(arr);
+        console.log(Array.isArray(row) ? row.join(' ') : row);
+        return this;
+    }
+}
+exports.LoggerService = LoggerService;