lemon-core 3.0.0 → 3.1.1

package/dist/cores/storage/proxy-storage-service.js

@@ -0,0 +1,913 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueFieldManager = exports.ModelUtil = exports.TypedStorageService = exports.ProxyStorageService = exports.GeneralModelFilter = exports.GeneralKeyMaker = exports.CORE_FIELDS = void 0;
+/**
+ * `proxy-storage-service.js`
+ * - common service for `accounts`
+ *
+ *
+ * @author      Steve Jung <steve@lemoncloud.io>
+ * @date        2019-12-27 initial service skeleton.
+ *
+ * @copyright (C) 2019 LemonCloud Co Ltd. - All Rights Reserved.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const engine_1 = require("../../engine/");
+const storage_service_1 = require("./storage-service");
+const test_helper_1 = require("../../common/test-helper");
+const general_api_controller_1 = require("../../controllers/general-api-controller");
+const NS = engine_1.$U.NS('PSTR', 'blue'); // NAMESPACE TO BE PRINTED.
+//NOTE! - BE WARE TO USE `ts-transformer-keys` DUE TO MISSING `ttypescript`
+// export const CORE_FIELDS: string[] = keys<CoreModel>().filter(_ => !_.startsWith('_'));
+// _inf(NS, '! CORE_FIELDS =', CORE_FIELDS.join(', ')); // for debugging.
+exports.CORE_FIELDS = 'ns,type,sid,uid,gid,lock,next,meta,createdAt,updatedAt,deletedAt'.split(',');
+/**
+ * class: `GeneralKeyMaker`
+ * - use ':' as delimiter to join [ns, type, id]
+ */
+class GeneralKeyMaker {
+    constructor(ns = '', delimiter = ':') {
+        this.NS = ns;
+        this.DELIMITER = delimiter;
+    }
+    asKey$(type, id) {
+        if (!id)
+            throw new Error('@id (model-id) is required!');
+        const ns = `${this.NS || ''}`;
+        const _id = [ns, `${type || ''}`, id].map(_ => _.replace(/[:]/gi, '-')).join(this.DELIMITER);
+        const res = { ns, id, type, _id };
+        return res;
+    }
+}
+exports.GeneralKeyMaker = GeneralKeyMaker;
+/**
+ * class: `GeneralModelFilter`
+ * - general model-filter with differential update.
+ * - to customize, override this class.
+ */
+// eslint-disable-next-line prettier/prettier
+class GeneralModelFilter {
+    /**
+     * default constructor
+     */
+    constructor(fields) {
+        this.FIELDS = fields;
+    }
+    /**
+     * parse `.meta` to json
+     * @param model     the current model
+     * @param origin    the origin model
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    afterRead(model, origin) {
+        // _log(NS, `filter.afterRead(${model._id || ''})....`);
+        if (!model.meta)
+            return model;
+        const meta = model.meta;
+        model.meta = meta && typeof meta == 'string' && meta.startsWith('{') ? JSON.parse(meta) : meta;
+        return model;
+    }
+    /**
+     * filter for before saving.
+     * - make sure data conversion
+     * - move the unknown fields to `.meta`.
+     *
+     * @param model     the current model
+     * @param origin    the origin model
+     */
+    beforeSave(model, origin) {
+        // _log(NS, `filter.beforeSave(${model._id})....`);
+        origin = origin || {};
+        const FIELDS = this.FIELDS && this.FIELDS.length ? this.FIELDS : null;
+        //! call service.onBeforeSave().
+        model = this.onBeforeSave(model, origin);
+        //TODO - accept only primitive types of field @191228.
+        //NOTE! - should not update the core field in save()
+        delete model.lock;
+        delete model.next;
+        //! load the meta data...
+        const $meta = (() => {
+            if (model.meta !== undefined && !model.meta)
+                return {};
+            const meta = model.meta || origin.meta || {}; // 만일, 파라미터에 meta 가 있다면, 클라이언트에서 직접 처리함.
+            return meta && typeof meta == 'string' ? JSON.parse(meta) : meta;
+        })();
+        //! move all fields to meta which is not defined in FIELDS.
+        model = Object.keys(model).reduce((N, key) => {
+            if (key.startsWith('_') || key.startsWith('$'))
+                return N;
+            if (key == 'createdAt' || key == 'updatedAt' || key == 'deletedAt')
+                return N;
+            if (/^[A-Z][A-Za-z0-9]*$/.test(key) && !/^[A-Z_]+$/.test(key))
+                return N; // ABC_DE 는 상수이며 OK, 다만, AbcDe 는 내부 오브젝트 이므로 무시!!!
+            if (key == 'meta')
+                return N; // meta itself.
+            if (FIELDS && FIELDS.indexOf(key) < 0 && FIELDS.indexOf('*' + key) < 0) {
+                $meta[key] = model[key];
+            }
+            else {
+                N[key] = model[key];
+            }
+            return N;
+        }, {});
+        model.meta = Object.keys($meta).length ? engine_1.$U.json($meta) : '';
+        //! handle for meta.
+        if (model.meta === '')
+            model.meta = null;
+        else if (typeof origin.meta == 'string' && model.meta == origin.meta)
+            delete model.meta;
+        else if (typeof origin.meta == 'object' && model.meta == engine_1.$U.json(origin.meta))
+            delete model.meta;
+        else if (!origin.meta && !model.meta)
+            model.meta = origin.meta;
+        //! filter out only the updated fields.
+        const res = Object.keys(model).reduce((N, key) => {
+            if (key.startsWith('_') || key.startsWith('$'))
+                return N; // ignore.
+            const org = origin[key];
+            const val = N[key];
+            if (!org && val)
+                return N;
+            else if (org && !val)
+                return N;
+            else if (org && typeof org === 'object') {
+                const org2 = engine_1.$U.json(org);
+                const val2 = typeof val === 'object' ? engine_1.$U.json(val) : val;
+                if (org2 == val2) {
+                    delete N[key];
+                }
+            }
+            else if ((val === '' || val === null) && (org === null || org === undefined)) {
+                //NOTE! - dynamo saves null for '' string.
+                delete N[key];
+            }
+            else if (val === org) {
+                delete N[key];
+            }
+            return N;
+        }, model);
+        //! if nothing to update, then returns null.
+        const keys = Object.keys(model).filter(_ => !_.startsWith('_') && !_.startsWith('$'));
+        if (keys.length <= 0)
+            return null;
+        //! returns the filtered node.
+        return res;
+    }
+    /**
+     * called after saving the model.
+     * - parse `.meta` back to json object.
+     *
+     * @param model     the saved model
+     * @param origin    the origin model.
+     */
+    afterSave(model, origin) {
+        return this.afterRead(model, origin);
+    }
+    /**
+     * called before updating the model.
+     * @param model         the updated model
+     * @param incrementals  (optional) incremental fields.
+     */
+    beforeUpdate(model, incrementals) {
+        return model;
+    }
+    /**
+     * called after updating the model.
+     * @param model     the updated model
+     */
+    afterUpdate(model) {
+        return this.afterRead(model, null);
+    }
+    /**
+     * override this `onBeforeSave()` in sub-class.
+     * @param model     the current model
+     * @param origin    (optional) the origin model
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onBeforeSave(model, origin) {
+        //TODO - override this function.
+        //! conversion data-type.
+        // if (model.count !== undefined) model.count = $U.N(model.count, 0);
+        return model;
+    }
+}
+exports.GeneralModelFilter = GeneralModelFilter;
+/**
+ * class: `ProxyStorageService`
+ * - support `nextSeq()`, `doLock()`, `doRelease()`
+ * - proxed storage-service to wrap the parent storage-service w/ more features.
+ * - table is supposed to have internal-key as `_id` string.
+ *
+ * **Usage**
+ * ```js
+ * type MyType = '' | 'test';
+ * interface MyModel extends CoreModel<MyType>{
+ *  name?: string;
+ * }
+ * const storage = new ProxyStorageService<MyModel, MyType>(this, 'TestTable', ['id','name']);
+ * const $test = storage.makeTypedStorageService('test');
+ * ```
+ */
+// eslint-disable-next-line prettier/prettier
+class ProxyStorageService {
+    /**
+     * create proxed storage-service.
+     *
+     * @param service   service to support `CoreKeyMakeable`
+     * @param storage   table-name or the parent storage-service
+     * @param fields    list of fields.
+     * @param filters   filters of `CoreModelFilterable`
+     * @param idName    (optional) internal partition-key (default as '_id')
+     */
+    constructor(service, storage, fields, filters, idName) {
+        /**
+         * say hello()
+         */
+        this.hello = () => `proxy-storage-service:${this.storage.hello()}`;
+        /**
+         * read by _id
+         */
+        this.read = (_id) => this.storage.read(_id);
+        /**
+         * read or create by _id
+         */
+        this.readOrCreate = (_id, model) => this.storage.readOrCreate(_id, model);
+        /**
+         * save by _id
+         */
+        this.save = (_id, model) => this.storage.save(_id, model);
+        /**
+         * update by _id
+         */
+        this.update = (_id, model, incrementals) => this.storage.update(_id, model, incrementals);
+        /**
+         * increment by _id
+         */
+        this.increment = (_id, model, $update) => this.storage.increment(_id, model, $update);
+        /**
+         * delete by _id
+         */
+        this.delete = (_id) => this.storage.delete(_id);
+        /**
+         * get key-id by type+id
+         */
+        this.asKey = (type, id) => {
+            if (typeof this.service.asKey == 'function') {
+                return this.service.asKey(type, `${id}`);
+            }
+            const $key = this.service.asKey$(type, `${id}`);
+            return $key[this.idName];
+        };
+        /**
+         * timer to generate the current-time (msec)
+         */
+        this.$timer = null;
+        this.setTimer = (timer) => {
+            const previous = this.$timer;
+            this.$timer = timer;
+            return previous;
+        };
+        this.getTime = () => {
+            if (this.$timer)
+                return this.$timer();
+            return new Date().getTime();
+        };
+        this.idName = idName === undefined ? '_id' : `${idName || ''}`;
+        this.service = service;
+        this.storage =
+            typeof storage == 'string' ? ProxyStorageService.makeStorageService(storage, fields, idName) : storage;
+        this.filters = filters || new GeneralModelFilter(fields);
+    }
+    /**
+     * factory function to create this `proxy-storage-service`
+     * @param service   key-makeable
+     * @param table     table-name
+     * @param fields    list of fields.
+     * @param filters   model filter.
+     * @param idName    (optional) internal partition-key (default as '_id')
+     */
+    static create(service, table, fields, filters, idName) {
+        const storage = ProxyStorageService.makeStorageService(table, fields, idName);
+        const res = new ProxyStorageService(service, storage, fields, filters, idName);
+        return res;
+    }
+    /**
+     * get next auto-sequence number.
+     *
+     * @param type      type of seqeunce.
+     * @param initNext  initial next value if not exist.
+     */
+    nextSeq(type, initNext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, engine_1._log)(NS, `nextSeq(${type})..`);
+            const { createdAt, updatedAt } = this.asTime();
+            const _id = this.asKey(ProxyStorageService.TYPE_SEQUENCE, `${type}`);
+            let res = yield this.storage.increment(_id, { next: 1 }, { updatedAt }); // it will create new row if not exists. (like upset)
+            if (res.next == 1) {
+                const $key = this.service.asKey$(ProxyStorageService.TYPE_SEQUENCE, `${type}`);
+                initNext = initNext === undefined ? ProxyStorageService.AUTO_SEQUENCE : initNext;
+                const $upd = { next: initNext };
+                const $inc = Object.assign(Object.assign({}, $key), { createdAt, updatedAt });
+                res = yield this.storage.increment(_id, $upd, $inc); //! increment w/ update-set
+            }
+            return res.next;
+        });
+    }
+    /**
+     * get uuid by type.
+     * @param type
+     */
+    nextUuid(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, engine_1._log)(NS, `nextUuid(${type})..`);
+            return engine_1.$U.uuid();
+        });
+    }
+    /**
+     * get time-stamp as now.
+     */
+    asTime(currentTime) {
+        currentTime = currentTime || this.getTime();
+        const createdAt = currentTime;
+        const updatedAt = currentTime;
+        const deletedAt = currentTime;
+        return { createdAt, updatedAt, deletedAt };
+    }
+    /**
+     * delete sequence-key.
+     * @param type      type of seqeunce.
+     */
+    clearSeq(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, engine_1._log)(NS, `nextSeq(${type})..`);
+            const _id = this.asKey(ProxyStorageService.TYPE_SEQUENCE, `${type}`);
+            yield this.storage.delete(_id);
+        });
+    }
+    /**
+     * read model by key + id with optional auto creation.
+     *
+     * @param type      model-type
+     * @param id        node-id
+     * @param $create   (optional) initial model if not exist. (or throw 404 error)
+     */
+    doRead(type, id, $create) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const $key = this.service.asKey$(type, id);
+            const _id = this.asKey(type, id);
+            const model = yield this.storage.read(_id).catch((e) => {
+                if (`${e.message}`.startsWith('404 NOT FOUND') && $create) {
+                    const { createdAt, updatedAt } = this.asTime();
+                    return this.storage.update(_id, Object.assign(Object.assign(Object.assign({}, $create), $key), { createdAt, updatedAt, deletedAt: 0 }));
+                }
+                throw e;
+            });
+            //! make sure it has `_id`
+            model[this.idName] = _id;
+            const res = this.filters.afterRead(model);
+            return res;
+        });
+    }
+    /**
+     * delete model by id.
+     *
+     * @param type      model-type
+     * @param id        node-id
+     * @param destroy   flag to destroy (real delete)
+     */
+    doDelete(type, id, destroy = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _id = this.asKey(type, id);
+            if (destroy === undefined || destroy === true)
+                return this.storage.delete(_id);
+            const { createdAt, updatedAt, deletedAt } = this.asTime();
+            const $up = { updatedAt, deletedAt };
+            const $org = yield this.read(_id); //! it will make 404 if not found.
+            if (!$org.createdAt)
+                $up.createdAt = createdAt;
+            return this.update(_id, $up);
+        });
+    }
+    /**
+     * update model (or it will create automatically)
+     *
+     * @param type      model-type
+     * @param id        node-id
+     * @param node      model
+     * @param incrementals (optional) fields to increment
+     */
+    doUpdate(type, id, node, incrementals) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const $inc = Object.assign({}, incrementals); //! make copy.
+            const _id = this.asKey(type, id);
+            // const $key = this.service.asKey$(type, id);
+            const node2 = this.filters.beforeUpdate(Object.assign(Object.assign({}, node), { [this.idName]: _id }), $inc);
+            delete node2['_id'];
+            const { updatedAt } = this.asTime();
+            const model = yield this.update(_id, Object.assign(Object.assign({}, node2), { updatedAt }), $inc);
+            //! make sure it has `_id`
+            model[this.idName] = _id;
+            return this.filters.afterUpdate(model);
+        });
+    }
+    /**
+     * update model (or it will create automatically)
+     *
+     * @param type      model-type
+     * @param id        node-id
+     */
+    doIncrement(type, id, $inc, $up) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _id = this.asKey(type, id);
+            const { updatedAt } = this.asTime();
+            const model = yield this.increment(_id, Object.assign({}, $inc), Object.assign(Object.assign({}, $up), { updatedAt }));
+            //! make sure it has `_id`
+            model[this.idName] = _id;
+            return this.filters.afterUpdate(model);
+        });
+    }
+    /**
+     * save model by checking origin node.
+     * - use `doSave()` rather than `doUpdate()` for both create & update.
+     * - if `$create` is null, throw 404 error it if not found.
+     *
+     * @param type      model-type
+     * @param id        node-id
+     * @param node      node to save (or update)
+     * @param $create   (optional) initial creation model if not found.
+     */
+    doSave(type, id, node, $create) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //! read origin model w/o error.
+            const $org = (yield this.doRead(type, id, null).catch(e => {
+                if (`${e.message}`.startsWith('404 NOT FOUND'))
+                    return null; // mark null to create later.
+                throw e;
+            }));
+            //! if `$create` is undefined, create it with default $key.
+            const _id = this.asKey(type, id);
+            const model = Object.assign({}, node); // copy from param.
+            model[this.idName] = _id; //! make sure the internal id
+            //! apply filter.
+            const $ups = this.filters.beforeSave(model, $org); //! `$org` should be null if create.
+            (0, engine_1._log)(NS, `> ${type}[${id}].update =`, engine_1.$U.json($ups));
+            //! if null, then nothing to update.
+            if (!$ups) {
+                const res = { [this.idName]: _id };
+                return res;
+            }
+            //! determine of create or update.
+            const { createdAt, updatedAt } = this.asTime();
+            if ($org) {
+                const $save = Object.assign(Object.assign({}, $ups), { updatedAt });
+                const res = yield this.doUpdate(type, id, $save);
+                return this.filters.afterSave(res, $org); //! `$org` should be valid if update.
+            }
+            else {
+                const $key = this.service.asKey$(type, id);
+                const $save = Object.assign(Object.assign(Object.assign(Object.assign({}, $ups), $create), $key), { createdAt, updatedAt: createdAt, deletedAt: 0 });
+                const res = yield this.storage.save(_id, $save);
+                return this.filters.afterSave(res, null); //! `$org` should be null if create.
+            }
+        });
+    }
+    /**
+     * lock data-entry by type+id w/ limited time tick
+     * - WARN! must release lock by `doRelease()`
+     *
+     * `total-waited-time = tick * interval (msec)`
+     *
+     * @param type      model-type
+     * @param id        model-id
+     * @param tick      tick count to wait.
+     * @param interval  timeout interval per each tick (in msec, default 1000 = 1sec)
+     */
+    doLock(type, id, tick, interval) {
+        return __awaiter(this, void 0, void 0, function* () {
+            tick = engine_1.$U.N(tick, 30);
+            interval = engine_1.$U.N(interval, 1000);
+            if (typeof tick != 'number' || tick < 0)
+                throw new Error(`@tick (${tick}) is not valid!`);
+            if (typeof interval != 'number' || interval < 1)
+                throw new Error(`@interval (${interval}) is not valid!`);
+            const _id = this.asKey(type, id);
+            //! WARN! DO NOT MAKE ANY MODEL CREATION IN HERE.
+            // const $org = await this.storage.readOrCreate(_id, { lock: 0, ...$key } as any);
+            // _log(NS, `> $org[${type}/${id}].lock =`, $org.lock);
+            const thiz = this;
+            //! wait some time.
+            const wait = (timeout) => __awaiter(this, void 0, void 0, function* () {
+                return new Promise(resolve => {
+                    setTimeout(() => {
+                        resolve(timeout);
+                    }, timeout);
+                });
+            });
+            const incLock = (_id, lock) => __awaiter(this, void 0, void 0, function* () {
+                const $up = {};
+                const $in = { lock };
+                return thiz.storage.update(_id, $up, $in).then($t2 => {
+                    return engine_1.$U.N($t2.lock, 1);
+                });
+            });
+            //! recursive to wait lock()
+            const waitLock = (_id, ttl, int) => __awaiter(this, void 0, void 0, function* () {
+                //! try to check the current value.....
+                const lock = yield incLock(_id, 0).then(n => {
+                    if (n > 1)
+                        return n;
+                    //! then, try to increment the lock
+                    return incLock(_id, ttl > 0 ? 1 : 0);
+                });
+                (0, engine_1._log)(NS, `! waitLock(${_id}, ${ttl}). lock =`, lock);
+                if (lock == 1 || lock == 0) {
+                    return true;
+                }
+                else if (ttl > 0 && lock > 1) {
+                    return wait(int).then(() => waitLock(_id, ttl - 1, int));
+                }
+                else {
+                    throw new Error(`400 TIMEOUT - model[${_id}].lock = ${lock}`);
+                }
+            });
+            return waitLock(_id, tick, interval);
+        });
+    }
+    /**
+     * release lock by resetting lock = 0.
+     *
+     * @param type  model-type
+     * @param id    model-id
+     */
+    doRelease(type, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, engine_1._log)(NS, `doRelease(${type}, ${id})... `);
+            const _id = this.asKey(type, id);
+            const $up = { lock: 0 };
+            const node = yield this.storage.update(_id, $up).catch(() => ({ lock: 0 }));
+            const lock = engine_1.$U.N(node.lock, 1);
+            return lock === 0 ? true : false;
+        });
+    }
+    /**
+     * create storage-service w/ fields list.
+     * - idName should be `_id`
+     *
+     * @param table     table-name or dummy file name (ex: `dummy-data.yml`).
+     * @param fields    required for dynamo table.
+     * @param idName    internal partition-key name (default '_id')
+     */
+    static makeStorageService(table, fields, idName) {
+        if (!table)
+            throw new Error(`@table (table-name) is required!`);
+        idName = idName === undefined ? '_id' : `${idName || ''}`;
+        //! clear the duplicated string
+        const clearDuplicated = (arr) => arr.sort().reduce((L, val) => {
+            if (val && L.indexOf(val) < 0)
+                L.push(val);
+            return L;
+        }, []);
+        //! make internal storage-service by table
+        if (table.endsWith('.yml')) {
+            return new storage_service_1.DummyStorageService(table, table.split('.')[0], idName);
+        }
+        else {
+            if (!fields)
+                throw new Error(`@fields (list of field) is required!`);
+            fields = clearDuplicated(exports.CORE_FIELDS.concat(fields));
+            return new storage_service_1.DynamoStorageService(table, fields, idName);
+        }
+    }
+    /**
+     * create proxy-storage-service by type
+     * @param type      model-type
+     */
+    makeTypedStorageService(type) {
+        if (!type)
+            throw new Error(`@type (model-type) is required!`);
+        // if (!fields) throw new Error(`@fields[${type}] (list of field) is required!`);
+        const res = new TypedStorageService(this, type);
+        return res;
+    }
+}
+exports.ProxyStorageService = ProxyStorageService;
+ProxyStorageService.AUTO_SEQUENCE = 1000000;
+ProxyStorageService.TYPE_SEQUENCE = 'sequence';
+/**
+ * class: `TypedStorageService`
+ * - wrap id with type + id.
+ */
+// eslint-disable-next-line prettier/prettier
+class TypedStorageService {
+    constructor(service, type) {
+        /**
+         * show self service name
+         */
+        this.hello = () => `typed-storage-service:${this.type}/${this.storage.hello()}`;
+        /**
+         * get next auto-sequence id in number like `1000003`.
+         */
+        this.nextId = () => this.storage.nextSeq(this.type);
+        /**
+         * get uuid like `d01764cd-9ef2-41e2-9e88-68e79555c979`
+         */
+        this.nextUuid = () => this.storage.nextUuid(this.type);
+        /**
+         * read model by key + id with optional auto creation.
+         * - throws '404 NOT FOUND' if not found.
+         *
+         * @param id        node-id
+         */
+        this.read = (id) => this.storage.doRead(this.type, `${id || ''}`);
+        /**
+         * read model by key + id with optional auto creation.
+         *
+         * @param id        node-id
+         * @param model     initial model if not exist. (or throw 404 error)
+         */
+        this.readOrCreate = (id, model) => this.storage.doRead(this.type, `${id || ''}`, model);
+        /**
+         * update model (or it will create automatically)
+         *
+         * @param id        node-id
+         * @param model     model to update
+         * @param incrementals (optional) fields to increment.
+         */
+        this.update = (id, model, incrementals) => this.storage.doUpdate(this.type, `${id || ''}`, model, incrementals);
+        /**
+         * insert model w/ auto generated id
+         *
+         * @param model     model to insert
+         */
+        this.insert = (node) => __awaiter(this, void 0, void 0, function* () {
+            return this.nextId().then(_ => {
+                const id = `${_}`;
+                (0, engine_1._log)(NS, `> next-id[${this.type}] =`, id);
+                return this.readOrCreate(id, Object.assign(Object.assign({}, node), { id }));
+            });
+        });
+        /**
+         * update model (or it will create automatically)
+         *
+         * ```ts
+         * //before: { count: 1 };
+         * const res = await storage.increment(1, { count: 2 }, { total: 2 });
+         * //after : { count: 3, total: 2 }
+         * ```
+         *
+         * @param id            node-id
+         * @param $increments   model only with numbers
+         */
+        this.increment = (id, $increments, $update) => this.storage.doIncrement(this.type, `${id || ''}`, $increments, $update);
+        /**
+         * delete model by id.
+         *
+         * @param id        node-id
+         * @param destroy   flag to destroy (real delete)
+         */
+        this.delete = (id, destroy) => this.storage.doDelete(this.type, `${id || ''}`, destroy === undefined ? true : destroy);
+        /**
+         * save model by checking origin node.
+         * - use `doSave()` rather than `doUpdate()` for both create & update.
+         * - if `$create` is null, throw 404 error it if not found.
+         *
+         * @param id        node-id
+         * @param node      node to save (or update)
+         * @param $create   (optional) initial creation model.
+         */
+        this.save = (id, model, $create) => this.storage.doSave(this.type, `${id || ''}`, model, $create);
+        /**
+         * lock data-entry by type+id w/ limited time tick
+         * - WARN! must release lock by `release(id)`
+         *
+         * `total-waited-time = tick * interval (msec)`
+         *
+         * **[UPDATES]**
+         * 1. read original node (or, throw 404 error)
+         * 2. use internal lock.
+         *
+         * @param id        model-id to lock
+         * @param tick      tick count to wait.
+         * @param interval  timeout interval per each tick (in msec, default 1000 = 1sec)
+         */
+        this.lock = (id, tick, interval) => this.storage
+            .doRead(this.type, `${id || ''}`, null)
+            .then(node => this.storage.doLock(this.type, node.id, tick, interval));
+        /**
+         * release lock by resetting lock = 0.
+         * @param id    model-id
+         */
+        this.release = (id) => this.storage.doRelease(this.type, `${id || ''}`);
+        /**
+         * using `lock()`, guard func with auto lock & release.
+         *
+         * ```ts
+         * const res = await storage.guard(async ()=>{
+         *  return 'abc';
+         * });
+         * // res === 'abc'
+         * ```
+         */
+        this.guard = (id, handler, tick, interval) => __awaiter(this, void 0, void 0, function* () {
+            let locked = false;
+            return this.lock(id, tick, interval)
+                .then((_) => {
+                locked = _;
+                try {
+                    return handler();
+                }
+                catch (e) {
+                    return Promise.reject(e);
+                }
+            })
+                .then((_) => {
+                if (locked)
+                    return this.release(id).then(() => _);
+                return _;
+            })
+                .catch((e) => {
+                if (locked)
+                    return this.release(id).then(() => Promise.reject(e));
+                // throw e;
+                return Promise.reject(e);
+            });
+        });
+        /**
+         * make `UniqueFieldManager` for field.
+         */
+        this.makeUniqueFieldManager = (field) => new UniqueFieldManager(this, field);
+        /**
+         * make `GeneralAPIController` for REST API w/ supporting basic CRUD
+         */
+        this.makeGeneralAPIController = (search, uniqueField) => new general_api_controller_1.GeneralAPIController(this.type, this, search, uniqueField);
+        this.storage = service;
+        this.type = type;
+    }
+}
+exports.TypedStorageService = TypedStorageService;
+/**
+ * class: `ModelUtil`
+ * - Helper functions for model.
+ */
+class ModelUtil {
+}
+exports.ModelUtil = ModelUtil;
+ModelUtil.selfRead = (self, key, defValue) => {
+    const value = self[key];
+    return value === undefined ? defValue : value;
+};
+ModelUtil.selfPop = (self, key, defValue) => {
+    const value = ModelUtil.selfRead(self, key, defValue);
+    delete self[key];
+    return value;
+};
+/**
+ * attach `.pop()` method to object.
+ *
+ * ```js
+ * const data = CoreModelUtil.buildPop({'a':1});
+ * assert( 1 === data.pop('a) );
+ * const final = data.pop();
+ * assert( final == data );
+ */
+ModelUtil.buildPop = (thiz, popName = 'pop') => {
+    if (!thiz)
+        throw new Error('@thiz (object) is required!');
+    if (typeof thiz[popName] != 'undefined')
+        throw new Error(`.[${popName}] is duplicated!`);
+    thiz[popName] = function (key, defValue) {
+        if (!key) {
+            //! clear pop() if key is null.
+            delete this[popName];
+            return this;
+        }
+        else {
+            return ModelUtil.selfPop(this, key, defValue);
+        }
+    };
+    return thiz;
+};
+/**
+ * class: `UniqueFieldManager`
+ * - support `.{field}` is unique in typed-storage-service.
+ * - make lookup data entry to save the reverse mapping to origin id.
+ * - set `.stereo` as '#' to mark as lookup. (to filter out from Elastic.search())
+ * - set `.id` as `#{field}/{name}` or `#{name}`.
+ * - set `.meta` as origin id.
+ */
+class UniqueFieldManager {
+    constructor(storage, field = 'name') {
+        this.hello = () => `unique-field-manager:${this.type}/${this.field}:${this.storage.hello()}`;
+        this.type = storage.type;
+        this.storage = storage;
+        this.field = field;
+    }
+    /**
+     * validate value format
+     * - just check empty string.
+     * @param value unique value in same type+field.
+     */
+    validate(value) {
+        const name2 = `${value || ''}`.trim();
+        return name2 && value == name2 ? true : false;
+    }
+    /**
+     * convert to internal id by value
+     * @param value unique value in same type group.
+     */
+    asLookupId(value) {
+        return `#${this.field || ''}/${value || ''}`;
+    }
+    /**
+     * lookup model by value
+     * - use `.meta` property to link with the origin.
+     * - mark `.stereo` as to '#' to distinguish normal.
+     *
+     * @param value unique value in same type group.
+     * @param $creates (optional) create-set if not found.
+     */
+    findOrCreate(value, $creates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!value || typeof value != 'string')
+                throw new Error(`@${this.field} (string) is required!`);
+            if (!this.validate(value))
+                throw new Error(`@${this.field} (${value || ''}) is not valid!`);
+            const ID = this.asLookupId(value);
+            const field = `${this.field}`;
+            if (!$creates) {
+                // STEP.1 read the origin name map
+                const $map = yield this.storage.read(ID).catch(test_helper_1.NUL404);
+                const rid = $map && $map.meta;
+                if (!rid)
+                    throw new Error(`404 NOT FOUND - ${this.type}:${field}/${value}`);
+                // STEP.2 read the target node by stereo key.
+                const model = yield this.storage.read(rid);
+                return model;
+            }
+            else {
+                // STEP.0 validate if value is same
+                const $any = $creates || {};
+                if ($any[field] !== undefined && $any[field] !== value)
+                    throw new Error(`@${this.field} (${value}) is not same as (${$any[field]})!`);
+                // STEP.1 read the origin value map
+                const $new = { stereo: '#', meta: `${$creates.id || ''}`, [field]: value };
+                const $map = yield this.storage.readOrCreate(ID, $new);
+                const rid = ($map && $map.meta) || $creates.id;
+                //! check if already saved, and id is differ.
+                if ($any['id'] && $any['id'] != rid)
+                    throw new Error(`@id (${rid}) is not same as (${$any['id']})`);
+                // STEP.2 read the target node or create.
+                const $temp = Object.assign(Object.assign({}, $creates), { [field]: value });
+                const model = rid ? yield this.storage.readOrCreate(rid, $temp) : yield this.storage.insert($temp);
+                model[field] = value;
+                // STEP.3 update lookup key.
+                const newId = `${rid || model.id || ''}`;
+                if ($map.meta != newId) {
+                    const $upt = { meta: newId };
+                    yield this.storage.update(ID, $upt);
+                    $map.meta = newId;
+                }
+                //! returns.
+                return model;
+            }
+        });
+    }
+    /**
+     * update lookup table (or create)
+     *
+     * @param model target model
+     * @param value (optional) new value of model.
+     */
+    updateLookup(model, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            value = value || model[this.field];
+            if (!this.validate(value))
+                throw new Error(`@${this.field} (${value || ''}) is not valid!`);
+            const ID = this.asLookupId(value);
+            const field = `${this.field}`;
+            // STEP.0 validate if value has changed
+            const $any = model;
+            if ($any[field] && $any[field] !== value)
+                throw new Error(`@${this.field} (${value}) is not same as (${$any[field]})!`);
+            // STEP.1 check if value is duplicated.
+            const $org = yield this.storage.read(ID).catch(test_helper_1.NUL404);
+            const rid = $org && $org.meta;
+            if ($org && rid != model.id)
+                throw new Error(`400 DUPLICATED NAME - ${field}[${value}] is duplicated to ${this.type}[${rid}]`);
+            // STEP.2 save the name mapping.
+            const $new = Object.assign(Object.assign({}, model), { [field]: value, id: model.id });
+            return yield this.findOrCreate(value, $new);
+        });
+    }
+}
+exports.UniqueFieldManager = UniqueFieldManager;
+//# sourceMappingURL=proxy-storage-service.js.map