taon 21.0.51 → 21.0.53

package/lib-prod/base-classes/base-controller.js

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+import * as FormData from "form-data";
+import {
+  HttpResponseError
+} from "ng2-rest/lib-prod";
+import { crossPlatformPath, fse, path, CoreModels__NS__TaonHttpErrorCustomProp, UtilsTerminal__NS__waitMilliseconds } from "tnp-core/lib-prod";
+import { TaonController } from "../decorators/classes/controller-decorator";
+import { POST } from "../decorators/http/http-methods-decorators";
+import { Body, Query } from "../decorators/http/http-params-decorators";
+import { TaonBaseFileUploadMiddleware } from "./base-file-upload.middleware";
+import { TaonBaseInjector } from "./base-injector";
+let TaonBaseController = class extends TaonBaseInjector {
+  /**
+   * Hook that is called when taon app is inited
+   * (all contexts are created and inited)
+   */
+  async afterAllCtxInited(options) {
+  }
+  uploadFormDataToServer(formData, queryParams) {
+    return async (req, res) => {
+      const files = req.files;
+      if (!files) {
+        throw "No file(s) received";
+      }
+      const responseArr = files.map((f) => {
+        const savedAbs = crossPlatformPath(path.resolve(f.path));
+        return {
+          ok: true,
+          originalName: f.originalname,
+          savedAs: path.basename(savedAbs),
+          // savedPath: void 0, // not needed
+          size: f.size,
+          mimetype: f.mimetype
+        };
+      });
+      for (const res2 of responseArr) {
+        await this.afterFileUploadAction(res2, queryParams || {});
+      }
+      return responseArr;
+    };
+  }
+  //#endregion
+  //#region after file upload hook
+  /**
+   * Hook after file is uploaded
+   * through `uploadFormDataToServer` or `uploadLocalFileToServer`
+   */
+  afterFileUploadAction(file, queryParams) {
+  }
+  //#region upload local file to server
+  async uploadLocalFileToServer(absFilePath, options, queryParams) {
+    const stat = fse.statSync(absFilePath);
+    const stream = fse.createReadStream(absFilePath);
+    const form = new FormData();
+    form.append("file", stream, {
+      filename: path.basename(absFilePath),
+      knownLength: stat.size
+    });
+    const data = await this.uploadFormDataToServer(form, queryParams).request(
+      options || {}
+    );
+    return data.body.json;
+  }
+  //#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 || 1e3;
+    const taonRequest = options.request;
+    let maxTries = options.maxTries || Number.POSITIVE_INFINITY;
+    let i = 0;
+    let httpErrorsCount = 0;
+    while (true) {
+      await UtilsTerminal__NS__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__NS__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`
+        );
+      }
+    }
+  }
+};
+__decorateClass([
+  POST({
+    overrideContentType: "multipart/form-data",
+    middlewares: ({ parentMiddlewares }) => ({
+      ...parentMiddlewares,
+      TaonBaseFileUploadMiddleware
+    })
+  }),
+  __decorateParam(0, Body()),
+  __decorateParam(1, Query())
+], TaonBaseController.prototype, "uploadFormDataToServer", 1);
+TaonBaseController = __decorateClass([
+  TaonController({
+    className: "TaonBaseController"
+  })
+], TaonBaseController);
+export {
+  TaonBaseController
+};

package/lib-prod/base-classes/base-crud-controller.js

@@ -0,0 +1,235 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+import { ___NS__isArray, ___NS__isFunction, ___NS__isString, Helpers__NS__error, Helpers__NS__warn } from "tnp-core/lib-prod";
+import { TaonController } from "../decorators/classes/controller-decorator";
+import {
+  GET,
+  PUT,
+  DELETE,
+  POST,
+  PATCH
+} from "../decorators/http/http-methods-decorators";
+import { Query, Body } from "../decorators/http/http-params-decorators";
+import { ClassHelpers__NS__getClassFnFromObject, ClassHelpers__NS__getName } from "../helpers/class-helpers";
+import { Symbols__NS__metadata, Symbols__NS__old } from "../symbols";
+import { Validators__NS__preventUndefinedModel } from "../validators";
+import { TaonBaseController } from "./base-controller";
+let TaonBaseCrudController = class extends TaonBaseController {
+  //#region fields
+  db;
+  //#endregion
+  //#region init
+  async _() {
+    if (!___NS__isFunction(this.entityClassResolveFn)) {
+      Helpers__NS__warn(
+        `Skipping initing CRUD controller ${ClassHelpers__NS__getName(
+          this
+        )} because entityClassResolveFn is not provided.`
+      );
+      return;
+    }
+    let entityClassFn = this.entityClassResolveFn();
+    this.db = this.injectRepo(entityClassFn);
+    if (entityClassFn) {
+      const configEntity = Reflect.getMetadata(
+        Symbols__NS__metadata.options.entity,
+        ClassHelpers__NS__getClassFnFromObject(this)
+      );
+      if (configEntity?.createTable === false) {
+        Helpers__NS__warn(
+          `Table for entity ${ClassHelpers__NS__getName(
+            entityClassFn
+          )} will not be created. Crud will not work properly.`
+        );
+      }
+    } else {
+      Helpers__NS__error(`Entity class not provided for controller ${ClassHelpers__NS__getName(
+        this
+      )}.
+
+      Please provide entity as class property entityClassFn:
+
+      class ${ClassHelpers__NS__getName(this)} extends TaonBaseCrudController<Entity> {
+        // ...
+        entityClassResolveFn = ()=> MyEntityClass;
+        // ...
+      }
+
+      `);
+    }
+    await super._();
+  }
+  bufforedChanges(id, property, alreadyLength) {
+    return async (request, response) => {
+      const model = await this.db.getBy(id);
+      if (model === void 0) {
+        return;
+      }
+      Validators__NS__preventUndefinedModel(model, id);
+      let value = model[property];
+      let result;
+      if (___NS__isString(value) || ___NS__isArray(value)) {
+        result = value.slice(alreadyLength);
+      }
+      return result;
+    };
+  }
+  pagination(pageNumber = 1, pageSize = 10, search = "") {
+    return async (request, response) => {
+      if (this.db.repositoryExists) {
+        const query = {
+          page: pageNumber,
+          take: pageSize,
+          keyword: search
+        };
+        const take = query.take || 10;
+        const page = query.page || 1;
+        const skip = (page - 1) * take;
+        const keyword = query.keyword || "";
+        const [result, total] = await this.db.findAndCount({
+          // where: { name: Like('%' + keyword + '%') },
+          // order: { name: "DESC" },
+          take,
+          skip
+        });
+        response?.setHeader(Symbols__NS__old.X_TOTAL_COUNT, total);
+        return result;
+      }
+      return [];
+    };
+  }
+  getAll() {
+    return async (request, response) => {
+      if (this.db.repositoryExists) {
+        const { models, totalCount } = await this.db.getAll();
+        response?.setHeader(Symbols__NS__old.X_TOTAL_COUNT, totalCount);
+        return models;
+      }
+      return [];
+    };
+  }
+  getBy(id) {
+    return async () => {
+      const model = await this.db.getBy(id);
+      return model;
+    };
+  }
+  updateById(id, item) {
+    return async () => {
+      const model = await this.db.updateById(id, item);
+      return model;
+    };
+  }
+  patchById(id, item) {
+    return async () => {
+      const model = await this.db.updateById(id, item);
+      return model;
+    };
+  }
+  bulkUpdate(items) {
+    return async () => {
+      if (!Array.isArray(items) || items?.length === 0) {
+        return [];
+      }
+      const { models } = await this.db.bulkUpdate(items);
+      return models;
+    };
+  }
+  deleteById(id) {
+    return async () => {
+      const model = await this.db.deleteById(id);
+      return model;
+    };
+  }
+  bulkDelete(ids) {
+    return async () => {
+      const models = await this.db.bulkDelete(ids);
+      return models;
+    };
+  }
+  clearTable() {
+    return async () => {
+      await this.db.clear();
+    };
+  }
+  save(item) {
+    return async () => {
+      const model = await this.db.save(item);
+      return model;
+    };
+  }
+  bulkCreate(items) {
+    return async () => {
+      const models = await this.db.bulkCreate(items);
+      return models;
+    };
+  }
+  //#endregion
+};
+__decorateClass([
+  GET(),
+  __decorateParam(0, Query(`id`)),
+  __decorateParam(1, Query(`property`)),
+  __decorateParam(2, Query("alreadyLength"))
+], TaonBaseCrudController.prototype, "bufforedChanges", 1);
+__decorateClass([
+  GET(),
+  __decorateParam(0, Query("pageNumber")),
+  __decorateParam(1, Query("pageSize")),
+  __decorateParam(2, Query("search"))
+], TaonBaseCrudController.prototype, "pagination", 1);
+__decorateClass([
+  GET()
+], TaonBaseCrudController.prototype, "getAll", 1);
+__decorateClass([
+  GET(),
+  __decorateParam(0, Query(`id`))
+], TaonBaseCrudController.prototype, "getBy", 1);
+__decorateClass([
+  PUT(),
+  __decorateParam(0, Query(`id`)),
+  __decorateParam(1, Body())
+], TaonBaseCrudController.prototype, "updateById", 1);
+__decorateClass([
+  PATCH(),
+  __decorateParam(0, Query(`id`)),
+  __decorateParam(1, Body())
+], TaonBaseCrudController.prototype, "patchById", 1);
+__decorateClass([
+  PUT(),
+  __decorateParam(0, Body())
+], TaonBaseCrudController.prototype, "bulkUpdate", 1);
+__decorateClass([
+  DELETE(),
+  __decorateParam(0, Query(`id`))
+], TaonBaseCrudController.prototype, "deleteById", 1);
+__decorateClass([
+  DELETE(),
+  __decorateParam(0, Query(`ids`))
+], TaonBaseCrudController.prototype, "bulkDelete", 1);
+__decorateClass([
+  DELETE()
+], TaonBaseCrudController.prototype, "clearTable", 1);
+__decorateClass([
+  POST(),
+  __decorateParam(0, Body())
+], TaonBaseCrudController.prototype, "save", 1);
+__decorateClass([
+  POST(),
+  __decorateParam(0, Body())
+], TaonBaseCrudController.prototype, "bulkCreate", 1);
+TaonBaseCrudController = __decorateClass([
+  TaonController({ className: "TaonBaseCrudController" })
+], TaonBaseCrudController);
+export {
+  TaonBaseCrudController
+};

package/lib-prod/base-classes/base-custom-repository.js

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+import { TaonRepository } from "../decorators/classes/repository-decorator";
+import { TaonBaseInjector } from "./base-injector";
+let TaonBaseCustomRepository = class extends TaonBaseInjector {
+};
+TaonBaseCustomRepository = __decorateClass([
+  TaonRepository({ className: "TaonBaseCustomRepository" })
+], TaonBaseCustomRepository);
+export {
+  TaonBaseCustomRepository
+};

package/lib-prod/base-classes/base-entity.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+import { Entity } from "taon-typeorm/lib-prod";
+import { TaonBaseClass } from "./base-class";
+let TaonBaseEntity = class extends TaonBaseClass {
+  /**
+   * simple check if relation is ok
+   */
+  relation(relationName) {
+    return relationName;
+  }
+  /**
+   * simple check if relation is ok
+   */
+  relations(relationNames) {
+    return relationNames;
+  }
+};
+TaonBaseEntity = __decorateClass([
+  Entity()
+], TaonBaseEntity);
+export {
+  TaonBaseEntity
+};

package/lib-prod/base-classes/base-file-upload.middleware.js

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+import * as crypto from "crypto";
+import * as multer from "multer";
+import { crossPlatformPath, fse, path } from "tnp-core/lib-prod";
+import { TaonMiddleware } from "../decorators/classes/middleware-decorator";
+import {
+  TaonBaseMiddleware
+} from "./base-middleware";
+let TaonBaseFileUploadMiddleware = class extends TaonBaseMiddleware {
+  async interceptServerMethod({ req, res, next }, { methodName, expressPath }) {
+    return this.middleware()(req, res, next);
+  }
+  //#region upload Dir
+  uploadDir() {
+    return crossPlatformPath([this.ctx.cwd, "uploaded-files"]);
+  }
+  //#endregion
+  //#region storage
+  storage() {
+    const uploadDir = this.uploadDir();
+    if (!fse.existsSync(uploadDir)) {
+      try {
+        fse.mkdirSync(uploadDir, { recursive: true });
+      } catch (error) {
+      }
+    }
+    return multer.diskStorage({
+      destination: (_req, _file, cb) => cb(null, uploadDir),
+      filename: (_req, file, cb) => {
+        const ext = path.extname(file.originalname).toLowerCase();
+        const base = path.basename(file.originalname, ext).replace(/[^\w.-]/g, "_");
+        const uniq = `${Date.now()}-${crypto.randomBytes(6).toString("hex")}`;
+        const filenameToProcess = `${base}-${uniq}${ext}`;
+        cb(null, filenameToProcess);
+      }
+    });
+  }
+  //#endregion
+  //#region upload
+  upload() {
+    return multer({
+      storage: this.storage(),
+      limits: { fileSize: 1024 * 1024 * 1024 }
+      // 1 GiB cap; tweak as needed
+      // TODO implement file filter if needed
+      // fileFilter: (_req, file, cb) => {
+      //   // accept only .zip by filename extension
+      //   if (path.extname(file.originalname).toLowerCase() !== '.zip') {
+      //     return cb(new Error('Only .zip files are allowed'));
+      //   }
+      //   cb(null, true);
+      // },
+    });
+  }
+  //#endregion
+  //#region middleware
+  middleware() {
+    return this.upload().any();
+  }
+  //#endregion
+};
+TaonBaseFileUploadMiddleware = __decorateClass([
+  TaonMiddleware({
+    className: "TaonBaseFileUploadMiddleware"
+  })
+], TaonBaseFileUploadMiddleware);
+export {
+  TaonBaseFileUploadMiddleware
+};