taon 19.0.65 → 19.0.67

package/websql/fesm2022/taon.mjs

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import * as coreHelpers from 'tnp-core/websql';
-import { _, Utils, UtilsMigrations, Helpers, UtilsOs, crossPlatformPath, CoreModels } from 'tnp-core/websql';
+import { _, Utils, UtilsMigrations, Helpers, UtilsOs, crossPlatformPath, CoreModels, UtilsTerminal } from 'tnp-core/websql';
 import { __decorate, __metadata, __param } from 'tslib';
 import * as tsorm from 'taon-typeorm/websql';
 import { OrignalClassKey, Entity, Table, TableIndex, EventSubscriber, DataSource } from 'taon-typeorm/websql';
@@ -10,7 +10,7 @@ import * as i0 from '@angular/core';
 import { InjectionToken, inject as inject$1, Injectable } from '@angular/core';
 import axios from 'axios';
 import { JSON10 } from 'json10/websql';
-import { Models as Models$1, Resource, RestHeaders, Mapping } from 'ng2-rest/websql';
+import { RestResponseWrapper, Models as Models$1, Resource, RestHeaders, Mapping, HttpResponseError } from 'ng2-rest/websql';
 import { Observable, Subject, from } from 'rxjs';
 import { config } from 'tnp-config/websql';
 import * as JSON5 from 'json5';
@@ -596,9 +596,26 @@ class BaseClass {
     async _() { }
     //#endregion
     //#region clone
-    clone(override) {
+    /**
+     *
+     * @param overrideObjOrFn if object is provided it will override values in cloned object,
+     * if function is provided it will be called with old cloned values and should return
+     * object with values to override
+     * @returns cloned instance of the class
+     */
+    clone(overrideObjOrFn) {
+        if (_.isString(overrideObjOrFn)) {
+            console.log(overrideObjOrFn);
+            throw new Error('String is not supported as .clone() method argument');
+        }
         const classFn = ClassHelpers.getClassFnFromObject(this);
-        return cloneObj(override, classFn);
+        if (_.isFunction(overrideObjOrFn)) {
+            // console.log('clone with fn');
+            const oldValues = (_.cloneDeep(this) || {});
+            return cloneObj(overrideObjOrFn(oldValues), classFn);
+        }
+        // console.log('clone normal');
+        return cloneObj(overrideObjOrFn, classFn);
     }
 }
 
@@ -830,6 +847,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
             type: Injectable
         }], ctorParameters: () => [] });
 
+// ! TODO make it as a nice way to wrap normal request
+class TaonRestResponseWrapper extends RestResponseWrapper {
+}
 var Models;
 (function (Models) {
     //#region models / class types
@@ -887,25 +907,6 @@ var Models;
     let Http;
     (function (Http) {
         Http.Rest = Models$1;
-        class Errors {
-            constructor(message, code = 400) {
-                this.message = message;
-                this.code = code;
-                this.toString = () => {
-                    return this.message;
-                };
-            }
-            static create(message, code = 400) {
-                return new Errors(message, code);
-            }
-            static entityNotFound(entity) {
-                return Errors.create(`Entity ${ClassHelpers.getName(entity)} not found`);
-            }
-            static custom(message, code = 400) {
-                return Errors.create(message, code);
-            }
-        }
-        Http.Errors = Errors;
         //#endregion
     })(Http = Models.Http || (Models.Http = {}));
     //#endregion
@@ -1294,9 +1295,6 @@ const getResponseValue = (response, options) => {
                 resolve(result);
             }
             catch (e) {
-                console.error(e);
-                console.error('[taon] Error during function call inside controller');
-                Helpers.renderError(e);
                 reject(e);
             }
         }
@@ -1325,6 +1323,12 @@ var TaonHelpers;
         return p && typeof p === 'string' && p.trim() !== '';
     };
     //#endregion
+    TaonHelpers.firstStringOrElemFromArray = (stringOrArrayOfString) => {
+        if (Array.isArray(stringOrArrayOfString)) {
+            return _.first(stringOrArrayOfString);
+        }
+        return stringOrArrayOfString;
+    };
     //#region try transform params
     TaonHelpers.tryTransformParam = param => {
         if (typeof param === 'string') {
@@ -1548,6 +1552,14 @@ class RealtimeSubsManager {
 
 //#region imports
 //#endregion
+/**
+ * Client for realtime communication
+ * you can listen to:
+ * - entity changes (any property in table changed)
+ * - entity custom property changes (specific property changed)
+ * - entity table changes (new instance added, instance removed)
+ * - custom events
+ */
 class RealtimeClient {
     constructor(core) {
         this.core = core;
@@ -1621,20 +1633,32 @@ class RealtimeClient {
     //#endregion
     //#region methods & getters  / listen changes entity
     /**
+     * Usage:
+     * myContext.realtimeClient.listenChangesEntity(myEntityInstance);
+     *
+     *
      * Changes trigger on backend needs to be done manually.. example code:
      *
-     * ...
-     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * myContext.realtimeServer.triggerEntityChanges(myEntityInstance);
      * ...
      */
-    listenChangesEntity(entityClassFn, idOrUniqValue, options) {
+    listenChangesEntity(entityClassFnOrObj, options) {
         options = options || {};
+        if (_.isObject(entityClassFnOrObj)) {
+            const orgObj = entityClassFnOrObj;
+            entityClassFnOrObj =
+                ClassHelpers.getClassFnFromObject(entityClassFnOrObj);
+            const uniqueKey = ClassHelpers.getUniqueKey(entityClassFnOrObj);
+            if (uniqueKey) {
+                options.idOrUniqValue = orgObj[uniqueKey];
+            }
+        }
         //#region parameters validation
         const { property, customEvent } = options;
-        const className = !customEvent && ClassHelpers.getName(entityClassFn);
+        const className = !customEvent && ClassHelpers.getName(entityClassFnOrObj);
         if (_.isString(property)) {
             if (property.trim() === '') {
-                throw new Error(`[Taon][listenChangesEntity.. incorect property '' for ${className}`);
+                throw new Error(`[Taon][listenChangesEntity.. incorrect property '' for ${className}`);
             }
         }
         //#endregion
@@ -1659,8 +1683,8 @@ to use socket realtime connection;
             }
             else {
                 roomName = _.isString(property)
-                    ? Symbols.REALTIME.ROOM_NAME_UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, className, property, idOrUniqValue)
-                    : Symbols.REALTIME.ROOM_NAME_UPDATE_ENTITY(this.core.ctx.contextName, className, idOrUniqValue);
+                    ? Symbols.REALTIME.ROOM_NAME_UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, className, property, options.idOrUniqValue)
+                    : Symbols.REALTIME.ROOM_NAME_UPDATE_ENTITY(this.core.ctx.contextName, className, options.idOrUniqValue);
             }
             const roomSubOptions = {
                 core: this.core,
@@ -1683,32 +1707,20 @@ to use socket realtime connection;
     }
     //#endregion
     //#region listen changes entity table
+    /**
+     * Listen changes entity table
+     * Example: for pagination, lists update ...
+     */
     listenChangesEntityTable(entityClassFn) {
         const className = ClassHelpers.getName(entityClassFn);
-        return this.listenChangesEntity(entityClassFn, void 0, {
+        return this.listenChangesEntity(entityClassFn, {
             customEvent: Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className),
         });
     }
     //#endregion
-    //#region listen change entity object
-    /**
-     * Changes trigger on backend needs to be done manually.. example code:
-     *
-     * ...
-     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
-     * // or
-     * Context.Realtime.Server.TrigggerEntityPropertyChanges(myEntityInstance,{ property: 'geolocationX' });
-     * ...
-     */
-    listenChangesEntityObj(entity, options) {
-        const classFn = ClassHelpers.getClassFnFromObject(entity);
-        const uniqueKey = ClassHelpers.getUniqueKey(classFn);
-        return this.listenChangesEntity(classFn, entity[uniqueKey], options);
-    }
-    //#endregion
     //#region listen changes custom event
     listenChangesCustomEvent(customEvent) {
-        return this.listenChangesEntity(void 0, void 0, {
+        return this.listenChangesEntity(void 0, {
             customEvent,
         });
     }
@@ -1734,6 +1746,17 @@ to use socket realtime connection;
 //#region imports
 /* */
 //#endregion
+/**
+ * Server for realtime communication
+ * you can trigger:
+ * - entity changes (any property in table changed)
+ * - entity custom property changes (specific property changed)
+ * - entity table changes (new instance added, instance removed)
+ * - custom events
+ *
+ * and also listen to:
+ * - custom events from yourself
+ */
 class RealtimeServer {
     // private jobs = {};
     constructor(core) {
@@ -1881,7 +1904,12 @@ class RealtimeServer {
     //#endregion
     //#region entity changes
     //#region methods & getters / trigger entity changes
-    triggerEntityChanges(entityObjOrClass, idToTrigger) {
+    triggerEntityChanges(entityObjOrClass, 
+    /**
+     * value of unique key property of entity instance
+     * (this value is not needed if entityObjOrClass is instance of entity)
+     */
+    idToTrigger) {
         if (this.core.ctx.disabledRealtime) {
             const className = ClassHelpers.getName(entityObjOrClass);
             console.warn(`[Taon][TriggerEntityChanges] Entity "${className}' is not realtime`);
@@ -1891,7 +1919,17 @@ class RealtimeServer {
     }
     //#endregion
     //#region methods & getters / trigger entity property changes
-    triggerEntityPropertyChanges(entityObjOrClass, property, idToTrigger) {
+    triggerEntityPropertyChanges(entityObjOrClass, 
+    /**
+     * property name or array of property names that changed
+     * for entity instance
+     */
+    property, 
+    /**
+     * value of unique key property of entity instance
+     * (this value is not needed if entityObjOrClass is instance of entity)
+     */
+    idToTrigger) {
         if (this.core.ctx.disabledRealtime) {
             const className = ClassHelpers.getName(entityObjOrClass);
             console.warn(`[Taon][TriggerEntityPropertyChanges][property=${property}] Entity "${className}' is not realtime`);
@@ -2710,6 +2748,12 @@ class EndpointContext {
         }
         return this.config?.logs === true;
     }
+    get logRoutes() {
+        if (_.isObject(this.config?.logs)) {
+            return !!this.config.logs.routes;
+        }
+        return this.config?.logs === true;
+    }
     get logDb() {
         if (_.isObject(this.config?.logs)) {
             return !!this.config.logs.db;
@@ -4157,9 +4201,7 @@ class EndpointContext {
     //#endregion
     //#region methods & getters / write active routes
     writeActiveRoutes() {
-        if (this.isRemoteHost ||
-            this.isRunOrRevertOnlyMigrationAppStart ||
-            this.skipWritingServerRoutes) {
+        if (this.isRemoteHost || this.isRunOrRevertOnlyMigrationAppStart) {
             return;
         }
         // const contexts: EndpointContext[] = [this];
@@ -4185,7 +4227,7 @@ class EndpointContext {
             `routes-${this.config.contextName}.rest`,
         ]);
         this.logFramework && console.log(`[taon] routes file: ${fileName} `);
-        // Helpers.log(JSON.stringify(routes, null, 4))
+        this.logRoutes && console.log(routes);
         /* */
         /* */
         /* */
@@ -4670,6 +4712,39 @@ class EndpointContext {
         };
     }
     //#endregion
+    sendError(res, error, req, expressPath) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
     //#region methods & getters / init client
     /**
      * client can be browser or nodejs (when remote host)
@@ -4704,8 +4779,8 @@ class EndpointContext {
         });
         //#endregion
         // : { received: any; /* Rest<any, any>  */ }
-        this.logHttp &&
-            console.log(`${httpRequestType?.toUpperCase()} ${expressPath} `);
+        // this.logHttp &&
+        //   console.log(`${httpRequestType?.toUpperCase()} ${expressPath} `);
         // console.log('INITING', methodConfig); // TODO inject in static
         //#region resolve storage
         // TODO not a good idea
@@ -5701,6 +5776,9 @@ let BaseRepository = class BaseRepository extends BaseCustomRepository {
         return models;
         //#endregion
     }
+    /**
+     * @deprecated use bulkSave instead
+     */
     async bulkCreate(items, options) {
         return this.bulkSave(items, options);
     }
@@ -6211,7 +6289,7 @@ const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, p
     else {
         options = { pathOrOptions, pathIsGlobal };
     }
-    const { overrideContentType, overrideResponseType, middlewares } = options;
+    const { overrideContentType, overrideResponseType, overrideExpressSendAsHtml, middlewares, } = options;
     methodConfig.methodName = propertyKey;
     methodConfig.middlewares = middlewares;
     methodConfig.type = method;
@@ -6236,12 +6314,44 @@ const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, p
     methodConfig.global = pathIsGlobal;
     methodConfig.contentType = overrideContentType;
     methodConfig.responseType = overrideResponseType;
+    methodConfig.overrideExpressSendAsHtml = overrideExpressSendAsHtml;
 };
 function GET(pathOrOptions, pathIsGlobal = false) {
     return function (target, propertyKey, descriptor) {
         metaReq('get', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
     };
 }
+/**
+ * Method for sending html website from text
+ * Example
+ *
+ * ```ts
+ * ...
+ * // in your taon controller
+ * ..Taon.Http.HTML()
+ * sendHtmlDummyWebsite(): Taon.ResponseHtml {
+ *  return  `
+      <html>
+        <head>
+          <title>Dummy website</title>
+        </head>
+        <body>
+          <h1>This is dummy website</h1>
+          <p>Served as HTML string from Taon controller method</p>
+        </body>
+      </html>
+ *  `; *
+ * }
+ * ...
+ * ```
+ */
+function HTML(pathOrOptions) {
+    return function (target, propertyKey, descriptor) {
+        const opt = pathOrOptions;
+        opt.overrideExpressSendAsHtml = true;
+        metaReq('get', opt, target, propertyKey, descriptor, pathOrOptions, opt.pathIsGlobal);
+    };
+}
 function HEAD(pathOrOptions, pathIsGlobal = false) {
     return function (target, propertyKey, descriptor) {
         metaReq('head', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
@@ -6281,6 +6391,9 @@ function metaParam(param, name, expire, defaultValue = undefined, target, proper
     };
     // console.log('params updated', methodConfig);
 }
+/**
+ * @deprecated use Taon.Http.Param.Path (is more safe and cleaner)
+ */
 function Path(name) {
     return function (target, propertyKey, parameterIndex) {
         metaParam('Path', name, undefined, {}, target, propertyKey, parameterIndex);
@@ -6314,7 +6427,7 @@ let BaseController = class BaseController extends BaseInjector {
      */
     async afterAllCtxInited(options) { }
     //#region upload form data to server
-    uploadFormDataToServer(formData) {
+    uploadFormDataToServer(formData, queryParams) {
         /* */
         /* */
         /* */
@@ -6349,11 +6462,13 @@ let BaseController = class BaseController extends BaseInjector {
      * Hook after file is uploaded
      * through `uploadFormDataToServer` or `uploadLocalFileToServer`
      */
-    afterFileUploadAction(file) {
+    afterFileUploadAction(file, queryParams) {
         // empty
     }
     //#region upload local file to server
-    async uploadLocalFileToServer(absFilePath, options) {
+    async uploadLocalFileToServer(absFilePath, options, queryParams) {
+        /* */
+        /* */
         /* */
         /* */
         /* */
@@ -6368,6 +6483,75 @@ let BaseController = class BaseController extends BaseInjector {
         /* */
         return (void 0);
     }
+    //#endregion
+    // async check() {
+    //   await this._waitForProperStatusChange({
+    //     request: () => this.uploadFormDataToServer(void 0, void 0).request(),
+    //     statusCheck: resp => resp.body.json[0].ok,
+    //   });
+    // }
+    /**
+     * Easy way to wait for status change with http (1s default) pooling.
+     *
+     * example (in sub class):
+     * ```ts
+        async check() {
+            await this.waitForProperStatusChange({
+              request: () => this.uploadFormDataToServer(void 0, void 0).request(),
+              statusCheck: resp => resp.body.json[0].ok,
+            });
+          }
+     * ```
+     */
+    async _waitForProperStatusChange(options) {
+        const poolingInterval = options.poolingInterval || 1000;
+        const taonRequest = options.request;
+        let maxTries = options.maxTries || Number.POSITIVE_INFINITY;
+        let i = 0;
+        let httpErrorsCount = 0;
+        while (true) {
+            await UtilsTerminal.waitMilliseconds(poolingInterval);
+            try {
+                const resp = await taonRequest({
+                    reqIndexNum: i,
+                    httpErrorsCount,
+                });
+                if (options.statusCheck && options.statusCheck(resp)) {
+                    return;
+                }
+            }
+            catch (error) {
+                httpErrorsCount++;
+                if (options.loopRequestsOnBackendError) {
+                    const isProperTaonError = error instanceof HttpResponseError &&
+                        error.body.json[CoreModels.TaonHttpErrorCustomProp];
+                    const isHttpError = error instanceof HttpResponseError && !isProperTaonError;
+                    const isUnknownError = !(error instanceof HttpResponseError);
+                    const resBool = await options.loopRequestsOnBackendError({
+                        taonError: isProperTaonError ? error : void 0,
+                        unknownHttpError: isHttpError ? error : void 0,
+                        unknownError: isUnknownError ? error : void 0,
+                        reqIndexNum: i,
+                        httpErrorsCount,
+                    });
+                    if (resBool) {
+                        i++;
+                        continue;
+                    }
+                    else {
+                        return;
+                    }
+                }
+                if (httpErrorsCount >
+                    (options.allowedHttpErrors || Number.POSITIVE_INFINITY)) {
+                    throw new Error(`Too many http errors (${httpErrorsCount}) for "${options.actionName}".`);
+                }
+            }
+            if (i++ > maxTries) {
+                throw new Error(`Timeout waiting for "${options.actionName}" to be finished. Waited for ${maxTries} seconds`);
+            }
+        }
+    }
 };
 __decorate([
     POST({
@@ -6378,8 +6562,9 @@ __decorate([
         }),
     }),
     __param(0, Body()),
+    __param(1, Query()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [FormData]),
+    __metadata("design:paramtypes", [FormData, Object]),
     __metadata("design:returntype", Object)
 ], BaseController.prototype, "uploadFormDataToServer", null);
 BaseController = __decorate([
@@ -6411,7 +6596,7 @@ let BaseCrudController = class BaseCrudController extends BaseController {
         else {
             Helpers.error(`Entity class not provided for controller ${ClassHelpers.getName(this)}.
 
-      Please provide entity as class propery entityClassFn:
+      Please provide entity as class property entityClassFn:
 
       class ${ClassHelpers.getName(this)} extends BaseCrudController<Entity> {
         // ...
@@ -6558,11 +6743,20 @@ let BaseCrudController = class BaseCrudController extends BaseController {
         //#endregion
     }
     //#endregion
+    //#region bulk delete
+    clearTable() {
+        //#region @websqlFunc
+        return async () => {
+            await this.db.clear();
+        };
+        //#endregion
+    }
+    //#endregion
     //#region create
-    create(item) {
+    save(item) {
         //#region @websqlFunc
         return async () => {
-            const model = await this.db.create(item);
+            const model = await this.db.save(item);
             return model;
         };
         //#endregion
@@ -6579,9 +6773,9 @@ let BaseCrudController = class BaseCrudController extends BaseController {
     }
 };
 __decorate([
-    GET(`/:id/property/:property`),
-    __param(0, Path(`id`)),
-    __param(1, Path(`property`)),
+    GET(),
+    __param(0, Query(`id`)),
+    __param(1, Query(`property`)),
     __param(2, Query('alreadyLength')),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, String, Number]),
@@ -6603,23 +6797,23 @@ __decorate([
     __metadata("design:returntype", Object)
 ], BaseCrudController.prototype, "getAll", null);
 __decorate([
-    GET(`/:id`),
-    __param(0, Path(`id`)),
+    GET(),
+    __param(0, Query(`id`)),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
 ], BaseCrudController.prototype, "getBy", null);
 __decorate([
-    PUT(`/:id`),
-    __param(0, Path(`id`)),
+    PUT(),
+    __param(0, Query(`id`)),
     __param(1, Body()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Object)
 ], BaseCrudController.prototype, "updateById", null);
 __decorate([
-    PATCH(`/:id`),
-    __param(0, Path(`id`)),
+    PATCH(),
+    __param(0, Query(`id`)),
     __param(1, Body()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
@@ -6633,26 +6827,32 @@ __decorate([
     __metadata("design:returntype", Object)
 ], BaseCrudController.prototype, "bulkUpdate", null);
 __decorate([
-    DELETE(`/:id`),
-    __param(0, Path(`id`)),
+    DELETE(),
+    __param(0, Query(`id`)),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number]),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
 ], BaseCrudController.prototype, "deleteById", null);
 __decorate([
-    DELETE(`/bulkDelete/:ids`),
-    __param(0, Path(`ids`)),
+    DELETE(),
+    __param(0, Query(`ids`)),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array]),
     __metadata("design:returntype", Object)
 ], BaseCrudController.prototype, "bulkDelete", null);
+__decorate([
+    DELETE(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], BaseCrudController.prototype, "clearTable", null);
 __decorate([
     POST(),
     __param(0, Body()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
-], BaseCrudController.prototype, "create", null);
+], BaseCrudController.prototype, "save", null);
 __decorate([
     POST(),
     __param(0, Body()),
@@ -6919,6 +7119,7 @@ var Http;
     Http.DELETE = DELETE;
     Http.PATCH = PATCH;
     Http.HEAD = HEAD;
+    Http.HTML = HTML;
     Http.Response = Models$1.HttpResponse;
     let Param;
     (function (Param) {
@@ -6933,6 +7134,11 @@ var Http;
 // TODO export all things
 var Taon;
 (function (Taon) {
+    Taon.error = (opt) => {
+        throw () => {
+            return opt;
+        };
+    };
     Taon.Http = Http;
     Taon.Base = Base;
     Taon.Orm = Orm;
@@ -6986,5 +7192,5 @@ var Taon;
  * Generated bundle index. Do not edit.
  */
 
-export { BaseContext, BaseController, BaseCustomRepository, BaseEntity, BaseFileUploadMiddleware, BaseMigration, BaseProvider, BaseRepository, CURRENT_HOST_BACKEND_PORT, CURRENT_HOST_URL, ClassHelpers, ContextsEndpointStorage, EndpointContext, Models, TAON_CONTEXT, Taon, TaonAdminService, TaonEntityKeysToOmitArr, apiPrefix, createContext, inject };
+export { BaseClass, BaseContext, BaseController, BaseCustomRepository, BaseEntity, BaseFileUploadMiddleware, BaseMigration, BaseProvider, BaseRepository, CURRENT_HOST_BACKEND_PORT, CURRENT_HOST_URL, ClassHelpers, ContextsEndpointStorage, EndpointContext, Models, TAON_CONTEXT, Taon, TaonAdminService, TaonEntityKeysToOmitArr, apiPrefix, createContext, inject };
 //# sourceMappingURL=taon.mjs.map