@minimaltech/node-infra 0.5.9-2 → 0.5.9-21

package/dist/helpers/worker-thread/worker-bus.js

@@ -2,22 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseWorkerBusHelper = exports.AbstractWorkerBusHelper = exports.BaseWorkerMessageBusHandlerHelper = exports.AbstractWorkerMessageBusHandlerHelper = void 0;
 const base_helper_1 = require("../../base/base.helper");
-// -------------------------------------------------------------------------------------------
 class AbstractWorkerMessageBusHandlerHelper extends base_helper_1.BaseHelper {
+    onMessage;
+    onClose;
+    onError;
+    onExit;
 }
 exports.AbstractWorkerMessageBusHandlerHelper = AbstractWorkerMessageBusHandlerHelper;
-// -------------------------------------------------------------------------------------------
 class BaseWorkerMessageBusHandlerHelper extends AbstractWorkerMessageBusHandlerHelper {
     constructor(opts) {
         super({ scope: opts.scope, identifier: opts.scope });
         this.onMessage = opts.onMessage;
-        this.onClose = (opts === null || opts === void 0 ? void 0 : opts.onClose) ? opts.onClose : () => { };
-        this.onExit = (opts === null || opts === void 0 ? void 0 : opts.onExit)
+        this.onClose = opts?.onClose ? opts.onClose : () => { };
+        this.onExit = opts?.onExit
             ? opts.onExit
             : (_opts) => {
                 this.logger.warn('[onExit] worker EXITED | exitCode: %s', _opts.exitCode);
             };
-        this.onError = (opts === null || opts === void 0 ? void 0 : opts.onError)
+        this.onError = opts?.onError
             ? opts.onError
             : (_opts) => {
                 this.logger.error('[onError] worker error: %s', _opts.error);
@@ -25,18 +27,16 @@ class BaseWorkerMessageBusHandlerHelper extends AbstractWorkerMessageBusHandlerH
     }
 }
 exports.BaseWorkerMessageBusHandlerHelper = BaseWorkerMessageBusHandlerHelper;
-// -------------------------------------------------------------------------------------------
 class AbstractWorkerBusHelper extends base_helper_1.BaseHelper {
+    port;
+    handler;
 }
 exports.AbstractWorkerBusHelper = AbstractWorkerBusHelper;
-// -------------------------------------------------------------------------------------------
 class BaseWorkerBusHelper extends AbstractWorkerBusHelper {
     constructor(opts) {
         super({ scope: opts.scope, identifier: opts.scope });
-        // Initialize
         this.port = opts.port;
         this.handler = opts.busHandler;
-        // Binding events
         this.port.on('message', message => {
             this.handler.onMessage({ message });
         });
@@ -54,15 +54,13 @@ class BaseWorkerBusHelper extends AbstractWorkerBusHelper {
         });
     }
     postMessage(opts) {
-        var _a, _b;
         if (!this.port) {
             this.logger.error('[postMessage] Failed to post message to main | Invalid parentPort!');
             return;
         }
-        (_a = this.onBeforePostMessage) === null || _a === void 0 ? void 0 : _a.call(this, opts);
+        this.onBeforePostMessage?.(opts);
         this.port.postMessage(opts.message, opts.transferList);
-        (_b = this.onAfterPostMessage) === null || _b === void 0 ? void 0 : _b.call(this, opts);
+        this.onAfterPostMessage?.(opts);
     }
 }
 exports.BaseWorkerBusHelper = BaseWorkerBusHelper;
-//# sourceMappingURL=worker-bus.js.map

package/dist/helpers/worker-thread/worker-pool.js

@@ -1,13 +1,4 @@
 "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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,13 +8,16 @@ const node_os_1 = __importDefault(require("node:os"));
 const base_helper_1 = require("../../base/base.helper");
 const error_utility_1 = require("../../utilities/error.utility");
 class WorkerPoolHelper extends base_helper_1.BaseHelper {
+    static instance;
+    registry;
+    numberOfCPUs;
+    ignoreMaxWarning;
     constructor(opts) {
-        var _a;
         super({ scope: WorkerPoolHelper.name });
         this.registry = new Map([]);
         const cpus = node_os_1.default.cpus();
         this.numberOfCPUs = cpus.length;
-        this.ignoreMaxWarning = (_a = opts === null || opts === void 0 ? void 0 : opts.ignoreMaxWarning) !== null && _a !== void 0 ? _a : false;
+        this.ignoreMaxWarning = opts?.ignoreMaxWarning ?? false;
     }
     static getInstance() {
         if (!WorkerPoolHelper.instance) {
@@ -58,21 +52,18 @@ class WorkerPoolHelper extends base_helper_1.BaseHelper {
         this.registry.set(key, worker);
         this.logger.info('[register] Successfully register worker | key: %s | poolSize: %s', key, this.registry.size);
     }
-    unregister(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { key } = opts;
-            if (!this.has({ key })) {
-                this.logger.warn('[unregister] SKIP unregister worker | Worker not existed | key: %s', key);
-                return;
-            }
-            const w = this.get({ key });
-            if (w === null || w === void 0 ? void 0 : w.worker) {
-                yield w.worker.terminate();
-            }
-            this.registry.delete(key);
-            this.logger.info('[unregister] Successfully unregister worker | key: %s | poolSize: %s', key, this.registry.size);
-        });
+    async unregister(opts) {
+        const { key } = opts;
+        if (!this.has({ key })) {
+            this.logger.warn('[unregister] SKIP unregister worker | Worker not existed | key: %s', key);
+            return;
+        }
+        const w = this.get({ key });
+        if (w?.worker) {
+            await w.worker.terminate();
+        }
+        this.registry.delete(key);
+        this.logger.info('[unregister] Successfully unregister worker | key: %s | poolSize: %s', key, this.registry.size);
     }
 }
 exports.WorkerPoolHelper = WorkerPoolHelper;
-//# sourceMappingURL=worker-pool.js.map

package/dist/index.js

@@ -23,4 +23,3 @@ __exportStar(require("./middlewares"), exports);
 __exportStar(require("./migrations"), exports);
 __exportStar(require("./mixins"), exports);
 __exportStar(require("./utilities"), exports);
-//# sourceMappingURL=index.js.map

package/dist/interceptors/content-range.interceptor.js

@@ -11,15 +11,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,159 +21,150 @@ const common_1 = require("../common");
 const core_1 = require("@loopback/core");
 const rest_1 = require("@loopback/rest");
 const get_1 = __importDefault(require("lodash/get"));
-let ContentRangeInterceptor = ContentRangeInterceptor_1 = class ContentRangeInterceptor {
+let ContentRangeInterceptor = class ContentRangeInterceptor {
+    static { ContentRangeInterceptor_1 = this; }
+    response;
+    static BINDING_KEY = `interceptors.${ContentRangeInterceptor_1.name}`;
     constructor(response) {
         this.response = response;
     }
     value() {
         return this.intercept.bind(this);
     }
-    // -------------------------------------------------------------------------------------
     identifyControllerType(opts) {
         const controller = opts.target;
-        if (controller === null || controller === void 0 ? void 0 : controller.repository) {
+        if (controller?.repository) {
             return 'single-entity';
         }
-        if ((controller === null || controller === void 0 ? void 0 : controller.sourceRepository) && (controller === null || controller === void 0 ? void 0 : controller.targetRepository)) {
+        if (controller?.sourceRepository && controller?.targetRepository) {
             return 'relation-entity';
         }
         return undefined;
     }
-    // -------------------------------------------------------------------------------------
-    handleSingleEntity(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const { context } = opts;
-            const { args, target } = context;
-            const controller = target;
-            let filter = {};
-            filter = args === null || args === void 0 ? void 0 : args[0];
-            if (!controller.repository) {
-                return;
-            }
-            const repository = controller.repository;
-            if (!filter) {
-                filter = {
-                    skip: 0,
-                    limit: (_a = controller === null || controller === void 0 ? void 0 : controller.defaultLimit) !== null && _a !== void 0 ? _a : common_1.App.DEFAULT_QUERY_LIMIT,
-                    where: {},
-                };
-            }
-            const { where = {}, skip = 0, limit = (_b = controller === null || controller === void 0 ? void 0 : controller.defaultLimit) !== null && _b !== void 0 ? _b : common_1.App.DEFAULT_QUERY_LIMIT, } = filter;
-            const countRs = yield repository.count(where);
-            const start = 0 + skip;
-            const end = Math.min(start + limit, countRs.count);
-            this.response.set('Content-Range', `records ${start}-${end > 0 ? end - 1 : end}/${countRs.count}`);
-        });
+    async handleSingleEntity(opts) {
+        const { context } = opts;
+        const { args, target } = context;
+        const controller = target;
+        let filter = {};
+        filter = args?.[0];
+        if (!controller.repository) {
+            return;
+        }
+        const repository = controller.repository;
+        if (!filter) {
+            filter = {
+                skip: 0,
+                limit: controller?.defaultLimit ?? common_1.App.DEFAULT_QUERY_LIMIT,
+                where: {},
+            };
+        }
+        const { where = {}, skip = 0, limit = controller?.defaultLimit ?? common_1.App.DEFAULT_QUERY_LIMIT, } = filter;
+        const countRs = await repository.count(where);
+        const start = 0 + skip;
+        const end = Math.min(start + limit, countRs.count);
+        this.response.set('Content-Range', `records ${start}-${end > 0 ? end - 1 : end}/${countRs.count}`);
     }
-    // -------------------------------------------------------------------------------------
-    handleRelationalEntity(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const { context } = opts;
-            const { args, target } = context;
-            const controller = target;
-            const relation = controller.relation;
-            if (!relation) {
-                return;
-            }
-            const refId = args[0];
-            let filter = args[1];
-            const ref = (_a = (0, get_1.default)(controller.sourceRepository, relation.name)) === null || _a === void 0 ? void 0 : _a(refId);
-            if (!controller.sourceRepository || !controller.targetRepository || !refId || !ref) {
-                return;
+    async handleRelationalEntity(opts) {
+        const { context } = opts;
+        const { args, target } = context;
+        const controller = target;
+        const relation = controller.relation;
+        if (!relation) {
+            return;
+        }
+        const refId = args[0];
+        let filter = args[1];
+        const ref = (0, get_1.default)(controller.sourceRepository, relation.name)?.(refId);
+        if (!controller.sourceRepository || !controller.targetRepository || !refId || !ref) {
+            return;
+        }
+        if (!filter) {
+            filter = {
+                skip: 0,
+                limit: controller?.defaultLimit ?? common_1.App.DEFAULT_QUERY_LIMIT,
+                where: {},
+            };
+        }
+        const { limit = common_1.App.DEFAULT_QUERY_LIMIT, skip = 0, where } = filter;
+        switch (relation.type) {
+            case common_1.EntityRelations.HAS_MANY_THROUGH: {
+                const throughConstraint = await ref.getThroughConstraintFromSource();
+                const throughRepository = await ref.getThroughRepository();
+                const thoughInstances = await throughRepository.find({
+                    where: { ...throughConstraint },
+                });
+                const targetConstraint = await ref.getTargetConstraintFromThroughModels(thoughInstances);
+                const countRs = await controller.targetRepository.count({
+                    ...where,
+                    ...targetConstraint,
+                });
+                const start = 0 + skip;
+                const end = Math.min(start + limit, countRs.count);
+                this.response.set('Content-Range', `records ${start}-${end > 0 ? end - 1 : end}/${countRs.count}`);
+                break;
             }
-            if (!filter) {
-                filter = {
-                    skip: 0,
-                    limit: (_b = controller === null || controller === void 0 ? void 0 : controller.defaultLimit) !== null && _b !== void 0 ? _b : common_1.App.DEFAULT_QUERY_LIMIT,
-                    where: {},
-                };
+            case common_1.EntityRelations.HAS_MANY: {
+                const targetConstraint = ref.constraint;
+                const countRs = await controller.targetRepository.count({
+                    ...where,
+                    ...targetConstraint,
+                });
+                const start = 0 + skip;
+                const end = Math.min(start + limit, countRs.count);
+                this.response.set('Content-Range', `records ${start}-${end > 0 ? end - 1 : end}/${countRs.count}`);
+                break;
             }
-            const { limit = common_1.App.DEFAULT_QUERY_LIMIT, skip = 0, where } = filter;
-            switch (relation.type) {
-                case common_1.EntityRelations.HAS_MANY_THROUGH: {
-                    const throughConstraint = yield ref.getThroughConstraintFromSource();
-                    const throughRepository = yield ref.getThroughRepository();
-                    const thoughInstances = yield throughRepository.find({
-                        where: Object.assign({}, throughConstraint),
-                    });
-                    const targetConstraint = yield ref.getTargetConstraintFromThroughModels(thoughInstances);
-                    const countRs = yield controller.targetRepository.count(Object.assign(Object.assign({}, where), targetConstraint));
-                    const start = 0 + skip;
-                    const end = Math.min(start + limit, countRs.count);
-                    this.response.set('Content-Range', `records ${start}-${end > 0 ? end - 1 : end}/${countRs.count}`);
-                    break;
-                }
-                case common_1.EntityRelations.HAS_MANY: {
-                    const targetConstraint = ref.constraint;
-                    const countRs = yield controller.targetRepository.count(Object.assign(Object.assign({}, where), targetConstraint));
-                    const start = 0 + skip;
-                    const end = Math.min(start + limit, countRs.count);
-                    this.response.set('Content-Range', `records ${start}-${end > 0 ? end - 1 : end}/${countRs.count}`);
-                    break;
-                }
-                default: {
-                    return [];
-                }
+            default: {
+                return [];
             }
-        });
+        }
     }
-    // -------------------------------------------------------------------------------------
-    enrichResponseContentRange(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { context } = opts;
-            const { target } = context;
-            const controllerType = this.identifyControllerType({ target });
-            switch (controllerType) {
-                // Normal entity controller
-                case 'single-entity': {
-                    yield this.handleSingleEntity(opts);
-                    break;
-                }
-                // Relational entity controller
-                case 'relation-entity': {
-                    yield this.handleRelationalEntity(opts);
-                    break;
-                }
-                default: {
-                    return;
-                }
+    async enrichResponseContentRange(opts) {
+        const { context } = opts;
+        const { target } = context;
+        const controllerType = this.identifyControllerType({ target });
+        switch (controllerType) {
+            case 'single-entity': {
+                await this.handleSingleEntity(opts);
+                break;
             }
-        });
-    }
-    intercept(context, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield next();
-            if (this.response.writableEnded) {
-                return result;
+            case 'relation-entity': {
+                await this.handleRelationalEntity(opts);
+                break;
             }
-            this.response.set('Access-Control-Expose-Headers', 'Content-Length, Content-Type, Content-Range');
-            if (!(context === null || context === void 0 ? void 0 : context.methodName)) {
-                return result;
+            default: {
+                return;
             }
-            if (this.response.get('Content-Range')) {
-                return result;
+        }
+    }
+    async intercept(context, next) {
+        const result = await next();
+        if (this.response.writableEnded) {
+            return result;
+        }
+        this.response.set('Access-Control-Expose-Headers', 'Content-Length, Content-Type, Content-Range');
+        if (!context?.methodName) {
+            return result;
+        }
+        if (this.response.get('Content-Range')) {
+            return result;
+        }
+        const { methodName } = context;
+        switch (methodName) {
+            case 'find': {
+                await this.enrichResponseContentRange({ context, result });
+                break;
             }
-            const { methodName } = context;
-            switch (methodName) {
-                case 'find': {
-                    yield this.enrichResponseContentRange({ context, result });
-                    break;
-                }
-                default: {
-                    break;
-                }
+            default: {
+                break;
             }
-            return result;
-        });
+        }
+        return result;
     }
 };
 exports.ContentRangeInterceptor = ContentRangeInterceptor;
-ContentRangeInterceptor.BINDING_KEY = `interceptors.${ContentRangeInterceptor_1.name}`;
 exports.ContentRangeInterceptor = ContentRangeInterceptor = ContentRangeInterceptor_1 = __decorate([
     (0, core_1.injectable)({ tags: { key: ContentRangeInterceptor.BINDING_KEY } }),
     __param(0, (0, core_1.inject)(rest_1.RestBindings.Http.RESPONSE)),
     __metadata("design:paramtypes", [Object])
 ], ContentRangeInterceptor);
-//# sourceMappingURL=content-range.interceptor.js.map

package/dist/interceptors/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./content-range.interceptor"), exports);
-//# sourceMappingURL=index.js.map

package/dist/middlewares/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./request-body-parser.middleware"), exports);
 __exportStar(require("./request-spy.middleware"), exports);
-//# sourceMappingURL=index.js.map

package/dist/middlewares/request-body-parser.middleware.js

@@ -8,15 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -33,9 +24,8 @@ let RequestBodyParserMiddleware = RequestBodyParserMiddleware_1 = class RequestB
     }
     handle(context) {
         return new Promise((resolve, reject) => {
-            var _a;
             const { request } = context;
-            const contentType = (_a = request.headers['content-type']) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const contentType = request.headers['content-type']?.toLowerCase();
             switch (contentType) {
                 case 'application/x-www-form-urlencoded': {
                     const urlencoded = new rest_1.UrlEncodedBodyParser({
@@ -57,11 +47,9 @@ let RequestBodyParserMiddleware = RequestBodyParserMiddleware_1 = class RequestB
             }
         });
     }
-    middleware(context, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.handle(context);
-            return next();
-        });
+    async middleware(context, next) {
+        await this.handle(context);
+        return next();
     }
     value() {
         return (context, next) => {
@@ -77,4 +65,3 @@ exports.RequestBodyParserMiddleware = RequestBodyParserMiddleware = RequestBodyP
     })),
     __metadata("design:paramtypes", [])
 ], RequestBodyParserMiddleware);
-//# sourceMappingURL=request-body-parser.middleware.js.map

package/dist/middlewares/request-spy.middleware.js

@@ -24,23 +24,22 @@ let RequestSpyMiddleware = RequestSpyMiddleware_1 = class RequestSpyMiddleware e
         super({ scope: RequestSpyMiddleware_1.name });
     }
     handle(context) {
-        var _a, _b, _c;
         try {
             const { request } = context;
             const requestId = (0, parse_utility_1.getUID)();
             (0, set_1.default)(request, 'requestId', requestId);
             const { url = '', method, body, query, path, headers } = request;
-            const requestUrl = (_a = decodeURIComponent(url)) === null || _a === void 0 ? void 0 : _a.replace(/(?:\r\n|\r|\n| )/g, '');
+            const requestUrl = decodeURIComponent(url)?.replace(/(?:\r\n|\r|\n| )/g, '');
             const requestedRemark = {
                 id: requestId,
                 url: requestUrl,
                 method,
-                path: path !== null && path !== void 0 ? path : 'N/A',
-                query: query !== null && query !== void 0 ? query : 'N/A',
+                path: path ?? 'N/A',
+                query: query ?? 'N/A',
                 body,
             };
             (0, set_1.default)(request, 'requestedRemark', requestedRemark);
-            const requestForwardedIp = (_c = (_b = headers['x-real-ip']) !== null && _b !== void 0 ? _b : headers['x-forwarded-for']) !== null && _c !== void 0 ? _c : 'N/A';
+            const requestForwardedIp = headers['x-real-ip'] ?? headers['x-forwarded-for'] ?? 'N/A';
             (0, set_1.default)(request, 'requestForwardedIp', requestForwardedIp);
             this.logger.info('[spy][%s] Request Information | forwardedIp: %s | remark: %j', requestId, requestForwardedIp, requestedRemark);
         }
@@ -63,4 +62,3 @@ exports.RequestSpyMiddleware = RequestSpyMiddleware = RequestSpyMiddleware_1 = _
     })),
     __metadata("design:paramtypes", [])
 ], RequestSpyMiddleware);
-//# sourceMappingURL=request-spy.middleware.js.map

package/dist/migrations/base-path.js

@@ -3,4 +3,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.basePath = void 0;
 const node_path_1 = require("node:path");
 exports.basePath = (0, node_path_1.join)(__dirname, './data/');
-//# sourceMappingURL=base-path.js.map

package/dist/migrations/handler.js

@@ -1,18 +1,9 @@
 "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.migrate = exports.migration = exports.cleanUpMigration = void 0;
 const common_1 = require("../common");
 const helpers_1 = require("../helpers");
-const cleanUpMigration = (application, migrationProcesses) => __awaiter(void 0, void 0, void 0, function* () {
+const cleanUpMigration = async (application, migrationProcesses) => {
     helpers_1.applicationLogger.info('START | Clean up migrate database');
     for (const migrationProcess of migrationProcesses) {
         const { name, cleanFn } = migrationProcess;
@@ -21,16 +12,16 @@ const cleanUpMigration = (application, migrationProcesses) => __awaiter(void 0,
         }
         try {
             helpers_1.applicationLogger.info('[%s] DONE | Clean up migrate process', name);
-            yield cleanFn(application);
+            await cleanFn(application);
             helpers_1.applicationLogger.info('[%s] DONE | Clean up migrate process', name);
         }
         catch (error) {
             helpers_1.applicationLogger.error('[%s] FAILED | Clean up migrate process | Error: %s', name, error);
         }
     }
-});
+};
 exports.cleanUpMigration = cleanUpMigration;
-const m = (application, migrationProcesses) => __awaiter(void 0, void 0, void 0, function* () {
+const m = async (application, migrationProcesses) => {
     helpers_1.applicationLogger.info('[migration] START Migrating database');
     const migrationRepository = application.getSync('repositories.MigrationRepository');
     for (const migrationProcess of migrationProcesses) {
@@ -41,14 +32,14 @@ const m = (application, migrationProcesses) => __awaiter(void 0, void 0, void 0,
         let migrated = null;
         let migrateStatus = common_1.MigrationStatuses.UNKNOWN;
         try {
-            migrated = yield migrationRepository.findOne({ where: { name } });
-            if (!(options === null || options === void 0 ? void 0 : options.alwaysRun) && migrated && migrated.status === common_1.MigrationStatuses.SUCCESS) {
+            migrated = await migrationRepository.findOne({ where: { name } });
+            if (!options?.alwaysRun && migrated && migrated.status === common_1.MigrationStatuses.SUCCESS) {
                 migrateStatus = migrated.status;
                 helpers_1.applicationLogger.info('[migration] SKIP | Migrate process: %s | status: %s', name, migrateStatus);
                 continue;
             }
             helpers_1.applicationLogger.info('[migration] START | Migrate process: %s', name);
-            yield fn(application);
+            await fn(application);
             migrateStatus = common_1.MigrationStatuses.SUCCESS;
             helpers_1.applicationLogger.info('[migration] DONE | Migrate process: %s', name);
         }
@@ -58,23 +49,22 @@ const m = (application, migrationProcesses) => __awaiter(void 0, void 0, void 0,
         }
         finally {
             if (migrated) {
-                yield migrationRepository.updateById(migrated.id, {
+                await migrationRepository.updateById(migrated.id, {
                     status: migrateStatus,
                 });
             }
             else {
-                yield migrationRepository.create({ name, status: migrateStatus });
+                await migrationRepository.create({ name, status: migrateStatus });
             }
         }
     }
     helpers_1.applicationLogger.info('[migration] DONE Migrating database');
-});
+};
 exports.migration = m;
-const migrate = (opts) => __awaiter(void 0, void 0, void 0, function* () {
+const migrate = async (opts) => {
     const { scope, application, processes } = opts;
     helpers_1.applicationLogger.info('[%s] START | Migrating database', scope.toUpperCase());
-    yield m(application, processes);
+    await m(application, processes);
     helpers_1.applicationLogger.info('[%s] DONE | Migrating database', scope.toUpperCase());
-});
+};
 exports.migrate = migrate;
-//# sourceMappingURL=handler.js.map

package/dist/migrations/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./handler"), exports);
-//# sourceMappingURL=index.js.map

package/dist/mixins/data-type.mixin.js

@@ -13,6 +13,11 @@ exports.DataTypeMixin = void 0;
 const repository_1 = require("@loopback/repository");
 const DataTypeMixin = (superClass) => {
     let Mixed = class Mixed extends superClass {
+        tValue;
+        nValue;
+        jValue;
+        bValue;
+        dataType;
     };
     __decorate([
         (0, repository_1.property)({
@@ -68,4 +73,3 @@ const DataTypeMixin = (superClass) => {
     return Mixed;
 };
 exports.DataTypeMixin = DataTypeMixin;
-//# sourceMappingURL=data-type.mixin.js.map