expresso-macchiato 0.3.0

package/dist/index.js

@@ -0,0 +1,825 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/RouterWrapper.ts
+var _express = require('express'); var _express2 = _interopRequireDefault(_express);
+
+// src/_utils.ts
+var _utilsloggerav = require('utils-logger-av');
+var MyLogger = class extends _utilsloggerav.Logger {
+  constructor() {
+    super(...arguments);
+    this.setFilePath = (filePath) => {
+      this.logFilePath = filePath;
+    };
+    this.fullLogOk = (service, message) => {
+      this.ok(`[${service.toUpperCase()}]: ${message}`);
+      this.logFile(`[${service.toUpperCase()}]: ${message}`);
+    };
+    this.fullLogNok = (service, error, ...args) => {
+      const errMessage = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _2 => _2.message]), () => ( error));
+      this.nok(`[${service.toUpperCase()}]: ${errMessage}`);
+      this.logFile(`[${service.toUpperCase()}]: ${errMessage}, ${args.join(",")}`, "error");
+    };
+  }
+};
+var log = new MyLogger({ primaryColor: "cyan", logFilePath: process.env.ERROR_FILE_PATH });
+var { fullLogOk, fullLogNok } = log;
+var apiOk = (res, status = 200, contentType) => ({ result: res, status, contentType, isOk: true });
+var apiNok = (err, status = 500) => ({ result: err, status, isOk: false });
+var errorCatcher = (res, err, errorsList, errorString) => {
+  if (errorString) fullLogNok("api-dynamicdb", errorString);
+  if (err instanceof Error === false) {
+    res.status(500).send({ message: err });
+    return;
+  }
+  const error = _nullishCoalesce((_nullishCoalesce(errorsList, () => ( {})))[err.message], () => ( null));
+  if (!error) res.status(500).send({ message: err.message });
+  else res.status(_nullishCoalesce(error.status, () => ( 500))).send({ message: _nullishCoalesce(error.responseMessage, () => ( err.message)) });
+};
+
+// src/DynamicDbRouter.ts
+var _typeorm = require('typeorm');
+
+// src/DbConnector.ts
+require('reflect-metadata');
+
+var _DbConnector = class _DbConnector {
+  constructor(projectConfig) {
+    this.connect = async (entities, migrations, sync) => {
+      try {
+        if (!this.projectConfig.DB_DIALECT || !this.projectConfig.DB_NAME) throw new Error("[DB-CONNECTOR]	Missing configs =>DB_DIALECT || DB_NAME");
+        const AppDataSource = new (0, _typeorm.DataSource)({
+          type: this.projectConfig.DB_DIALECT,
+          host: this.projectConfig.DB_HOST,
+          port: this.projectConfig.DB_PORT,
+          username: this.projectConfig.DB_USER,
+          password: this.projectConfig.DB_PASSWORD,
+          database: this.projectConfig.DB_NAME,
+          entities,
+          synchronize: _nullishCoalesce(sync, () => ( false)),
+          logging: false,
+          migrations
+        });
+        await AppDataSource.initialize();
+        if (_nullishCoalesce(sync, () => ( false))) await AppDataSource.synchronize();
+        else {
+          const executedMigrations = await AppDataSource.query(`SELECT name FROM sqlite_master WHERE type='table' AND name='migrations'`);
+          const executedMigrationNames = executedMigrations.map((migration) => migration.name);
+          if (migrations) {
+            log.teal("[DB-CONNECTOR] Running migrations:");
+            for (let migration of migrations) {
+              if (executedMigrationNames.includes(migration)) log.gray(`- Migration ${migration} already executed, skipping.`);
+              else {
+                log.yellow(`- Executing migration ${migration}`);
+                await AppDataSource.runMigrations();
+              }
+            }
+            log.teal("[DB-CONNECTOR] Migrations done");
+          }
+        }
+        _DbConnector.DataSource = AppDataSource;
+        log.magenta(`[DB-CONNECTOR] ORM CONNECTED`);
+      } catch (err) {
+        log.logError(err);
+      }
+    };
+    this.projectConfig = projectConfig;
+  }
+};
+_DbConnector.getDataSource = () => _DbConnector.DataSource;
+var DbConnector = _DbConnector;
+
+// src/Swagger.ts
+var _Swagger = class _Swagger {
+};
+// --- PRIVATE
+_Swagger.fromExpressParamsToSwagger = (str) => str.replace(/:(\w+)(?=\/|$)/g, "{$1}");
+_Swagger.restMethodToSwaggerKeyMapping = {
+  "GET": "get",
+  "POST": "post",
+  "PUT": "put",
+  "DELETE": "delete"
+};
+// ------------------------------------------------------- //
+// ------------------------------------------------------- //
+// ----------------------- GENERIC ----------------------- //
+// ------------------------------------------------------- //
+// ------------------------------------------------------- //
+_Swagger.addServer = (server) => _Swagger.apiDocument.servers.push(server);
+// Call at init to add current server
+_Swagger.generateOpenAPIDocument = () => JSON.parse(JSON.stringify(_Swagger.apiDocument, null, 2));
+// Generates json to be served in api
+_Swagger.apiDocument = // static document to be populated
+{
+  openapi: "3.0.4",
+  servers: [],
+  info: { title: "Dynamically Generated API", version: "1.0.0" },
+  paths: {},
+  components: {
+    schemas: {},
+    securitySchemes: {
+      bearerAuth: {
+        type: "http",
+        scheme: "bearer",
+        bearerFormat: "JWT"
+      }
+    }
+  },
+  security: [
+    { "bearerAuth": [] }
+  ]
+};
+// ------------------------------------------------------- //
+// ------------------------------------------------------- //
+// ----------------------- METHODS ----------------------- //
+// ------------------------------------------------------- //
+// ------------------------------------------------------- //
+/**
+ * @Description
+ * - ❌ ROUTER-WRAPPER.
+ * - 🛠️ ADD-API-PATH
+ * - This method is not directly to insert inside the structur of addApiPath but is useful to create Schemas while not using the routerWrapper
+ */
+_Swagger.addSchema = (schema, properties) => {
+  if (!_Swagger.apiDocument.components || !_Swagger.apiDocument.components.schemas) _Swagger.apiDocument.components = { schemas: {} };
+  if (!_Swagger.apiDocument.components.schemas[schema]) _Swagger.apiDocument.components.schemas[schema] = {
+    type: "object",
+    properties
+  };
+};
+/**
+ * @Description
+ * - ❌ ROUTER-WRAPPER.
+ * - 🛠️ ADD-API-PATH
+ * - This method is thought to reduce the code in the addApiPath method
+ * - You can create a schema while declaring it and associating to the path calling this method
+ */
+_Swagger.getBasicPost = (schema, required, parameters, properties, description) => ({
+  responses: {},
+  parameters,
+  requestBody: {
+    required,
+    description,
+    schemaName: schema,
+    schema: {
+      [schema]: {
+        type: "object",
+        properties
+      }
+    }
+  }
+});
+/**
+ * @Description
+ * - ❌ **ROUTER-WRAPPER.**
+ * - 🛠️ **ADD-API-PATH**
+ * - This method is thought to reduce the code in the addApiPath method
+ */
+_Swagger.getBasicGet = (parameters) => ({
+  responses: {},
+  parameters
+});
+/**
+ * @Description
+ * - ❌ ROUTER-WRAPPER.
+ * - This method is useful if you don't want to  use the router wrapper but add your swagger schema anyway.
+ * - **It is thought to be used inside the library**, iterating through the paths of the router wrapper.
+ * - **Devs can't use inside the parameters of a RouterWrapper constructor**
+ * - You can create the structure of a specified path and method, with a schema name that should be created elsewhere
+ */
+_Swagger.addSingleApiPath = (tag, basePath, _path, method, parameters, bodyObj, responses = {}) => {
+  const path2 = `${_Swagger.fromExpressParamsToSwagger(basePath)}${_Swagger.fromExpressParamsToSwagger(_path)}`;
+  const transcribedMethod = _Swagger.restMethodToSwaggerKeyMapping[method];
+  if (!_Swagger.apiDocument.paths[path2]) _Swagger.apiDocument.paths[path2] = {};
+  if (_Swagger.apiDocument.paths[path2][transcribedMethod]) return;
+  _Swagger.apiDocument.paths[path2][transcribedMethod] = {
+    responses,
+    parameters,
+    tags: [tag]
+  };
+  if (bodyObj) _Swagger.apiDocument.paths[path2][transcribedMethod].requestBody = {
+    required: _nullishCoalesce(bodyObj.required, () => ( false)),
+    description: bodyObj.description,
+    content: {
+      [_nullishCoalesce(bodyObj.comType, () => ( "application/json"))]: {
+        schema: { "$ref": "#/components/schemas/" + bodyObj.schema }
+      }
+    }
+  };
+};
+/**
+ * @Description
+ * - ❌ ROUTER-WRAPPER.
+ * - 🛠️ ADD-API-PATH
+ * - **This method is useful if you don't want to  use the router wrapper but add your swagger schema anyway**.
+ * - You can use other other methods of this class to ease the writing
+ * - It is thought to create a full section of apis (hypotetically under one single tag) **while you create the schema in the meanwhile**
+ */
+_Swagger._addApiPath = (tag, basePath, options) => {
+  const finalPaths = {};
+  const finalSchemas = {};
+  for (const _path in options) {
+    const path2 = `${basePath}${_path}`;
+    if (_optionalChain([options, 'access', _3 => _3[_path], 'access', _4 => _4.get, 'optionalAccess', _5 => _5.tags])) options[_path].get.tags = [tag];
+    finalPaths[path2] = {
+      get: options[_path].get,
+      $ref: options[_path].$ref,
+      head: options[_path].head,
+      parameters: options[_path].parameters
+    };
+    if (options[_path].get) options[_path].get.tags = [tag];
+    if (options[_path].post && options[_path].post.requestBody) {
+      finalPaths[path2].post = {
+        responses: {},
+        parameters: options[_path].post.parameters,
+        tags: [tag],
+        summary: options[_path].post.summary,
+        requestBody: {
+          required: options[_path].post.requestBody.required,
+          description: options[_path].post.requestBody.description,
+          content: {
+            "application/json": { schema: { "$ref": "#/components/schemas/" + options[_path].post.requestBody.schemaName } }
+          }
+        }
+      };
+      for (const key in options[_path].post.requestBody.schema) {
+        if (!finalSchemas[key]) finalSchemas[key] = options[_path].post.requestBody.schema[key];
+      }
+    }
+    if (options[_path].put && options[_path].put.requestBody) {
+      finalPaths[path2].put = {
+        responses: {},
+        tags: [tag],
+        parameters: options[_path].put.parameters,
+        summary: options[_path].put.summary,
+        requestBody: {
+          required: options[_path].put.requestBody.required,
+          description: options[_path].put.requestBody.description,
+          content: {
+            "application/json": { schema: { "$ref": "#/components/schemas/" + options[_path].put.requestBody.schemaName } }
+          }
+        }
+      };
+      for (const key in options[_path].put.requestBody.schema) {
+        if (!finalSchemas[key]) finalSchemas[key] = options[_path].put.requestBody.schema[key];
+      }
+    }
+    if (options[_path].delete) {
+      finalPaths[path2].delete = {
+        responses: {},
+        tags: [tag],
+        parameters: options[_path].delete.parameters,
+        summary: options[_path].delete.summary
+      };
+      if (options[_path].delete.requestBody) {
+        const finalComType = _nullishCoalesce(options[_path].delete.requestBody.comType, () => ( "application/json"));
+        finalPaths[path2].delete.requestBody = {
+          required: options[_path].delete.requestBody.required,
+          description: options[_path].delete.requestBody.description,
+          content: {
+            [finalComType]: {
+              schema: { "$ref": "#/components/schemas/" + options[_path].delete.requestBody.schemaName }
+            }
+          }
+        };
+        for (const key in options[_path].delete.requestBody.schema) {
+          if (!finalSchemas[key]) finalSchemas[key] = options[_path].delete.requestBody.schema[key];
+        }
+      }
+    }
+  }
+  for (const path2 in finalPaths) {
+    for (const method in finalPaths[path2]) {
+      const methodKey = method;
+      if (!_Swagger.apiDocument.paths[path2]) _Swagger.apiDocument.paths[path2] = {};
+      if (!_Swagger.apiDocument.paths[path2][methodKey]) _Swagger.apiDocument.paths[path2][methodKey] = finalPaths[path2][methodKey];
+    }
+  }
+  for (const schema in finalSchemas) {
+    if (!_Swagger.apiDocument.components || !_Swagger.apiDocument.components.schemas) _Swagger.apiDocument.components = { schemas: {} };
+    if (!_Swagger.apiDocument.components.schemas[schema]) _Swagger.apiDocument.components.schemas[schema] = finalSchemas[schema];
+  }
+};
+// ------------------------------------------------------- //
+// ------------------------------------------------------- //
+// ------------------------ MICRO ------------------------ //
+// ------------------------------------------------------- //
+// ------------------------------------------------------- //
+/**
+ * @Description
+ * - ✅ ROUTER-WRAPPER
+ * - Returns the tipical /:id parameter
+ */
+_Swagger.getIdParam = (pkLabel = "id") => ({ name: pkLabel, in: "path", required: true });
+/**
+ * @Description
+ * - ✅ ROUTER-WRAPPER
+ * - Returns the tipical list pagination parameters
+ */
+_Swagger.getPaginationParams = (options) => {
+  const listOptions = {
+    page: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.page]), () => ( 0)),
+    pageSize: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.pageSize]), () => ( 10)),
+    order: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.order]), () => ( "ASC")),
+    orderBy: _optionalChain([options, 'optionalAccess', _9 => _9.orderBy])
+  };
+  return Object.entries(listOptions).map(([key, val]) => ({ name: key, in: "query", default: val, required: false }));
+};
+/**
+ * @Description
+ * - ✅ ROUTER-WRAPPER
+ * - Creates the swagger schema expected by your api
+ */
+_Swagger.createMultipartSchema = (name = "file", props) => ({
+  type: "object",
+  properties: {
+    [name]: { type: "string", format: "binary" },
+    ..._nullishCoalesce(props, () => ( {}))
+  }
+});
+/**
+ * @Description
+ * - ✅ ROUTER-WRAPPER
+ * - Creates the swagger schema expected by your api
+ */
+_Swagger.createSchema = (props, required) => {
+  const finalSchemaObject = { type: "object", properties: {}, required };
+  for (const prop in props) {
+    if (typeof props[prop] === "string") finalSchemaObject.properties[prop] = { type: props[prop] };
+    else finalSchemaObject.properties[prop] = props[prop];
+  }
+  return finalSchemaObject;
+};
+var Swagger = _Swagger;
+
+// src/DynamicDbRouter.ts
+var _DynamicDbRouter = class _DynamicDbRouter {
+};
+_DynamicDbRouter.setTokenInstance = (tokenInstance) => {
+  _DynamicDbRouter.tokenInstance = tokenInstance;
+};
+_DynamicDbRouter.listOptionsKeys = ["pageSize", "page", "orderBy", "order"];
+_DynamicDbRouter.getTypefromReflection = (typeormType) => _nullishCoalesce(_DynamicDbRouter.typeormToSwaggerMapper[typeormType], () => ( typeormType));
+_DynamicDbRouter.typeormToSwaggerMapper = {
+  "text": "string",
+  "char varying": "string",
+  "char": "string",
+  "character varying": "string",
+  "character": "string",
+  "varchar": "string",
+  "varying character": "string",
+  "date": "date",
+  "datemultirange": "date",
+  "datetime": "date",
+  "int": "number",
+  "integer": "number",
+  "smallint": "number",
+  "bigint": "number",
+  "float": "number",
+  "real": "number",
+  "long": "number",
+  "double": "number",
+  "bit": "boolean",
+  "bool": "boolean",
+  "blob": "file"
+};
+_DynamicDbRouter.createDbRouter = (options) => {
+  if (!options.primaryKey) options.primaryKey = "id";
+  const avoidList = _nullishCoalesce(options.avoid, () => ( []));
+  if (!avoidList.includes("LIST")) options.router.get("/", async (req, res) => {
+    try {
+      let payload = null;
+      if (options.secure) {
+        if (_DynamicDbRouter.tokenInstance) payload = await _DynamicDbRouter.tokenInstance.authorize(req);
+        else throw new Error("Api secure option on but no token instance has been provided in the starter");
+      }
+      const listOptions = {};
+      for (const key in req.query) {
+        if (_DynamicDbRouter.listOptionsKeys.includes(key)) listOptions[key] = req.query[key];
+      }
+      const searchQuery = {};
+      for (const param of _nullishCoalesce(options.getParameters, () => ( []))) {
+        const val = _nullishCoalesce(req.query[param.name], () => ( void 0));
+        if (param.required && !val) throw new Error(`Params Error: ${param.name} required`);
+        if (val !== void 0) {
+          if (param.like) searchQuery[param.name] = _typeorm.Like.call(void 0, `%${val}%`);
+          else searchQuery[param.name] = _typeorm.Equal.call(void 0, val);
+        }
+      }
+      const secureSearchQuery = _DynamicDbRouter.setSecureParams("LIST", payload, options.secure);
+      const { page, pageSize, order, orderBy } = listOptions;
+      const entities = await options.entity.find({
+        where: { ...searchQuery, ...secureSearchQuery },
+        take: _nullishCoalesce(pageSize, () => ( 0)),
+        skip: (_nullishCoalesce(page, () => ( 0))) * (_nullishCoalesce(pageSize, () => ( 0))),
+        order: { [_nullishCoalesce(orderBy, () => ( options.primaryKey))]: _nullishCoalesce(order, () => ( "ASC")) },
+        select: options.returningProps
+      });
+      res.send(entities);
+    } catch (err) {
+      errorCatcher(res, err, void 0, `[GET]	/ => ${_nullishCoalesce(err.message, () => ( err))}`);
+    }
+  });
+  if (!avoidList.includes("GET")) options.router.get("/:id", async (req, res) => {
+    try {
+      let payload = null;
+      if (options.secure) {
+        if (_DynamicDbRouter.tokenInstance) payload = await _DynamicDbRouter.tokenInstance.authorize(req);
+        else throw new Error("Api secure option on but no token instance has been provided in the starter");
+      }
+      const secureSearchQuery = _DynamicDbRouter.setSecureParams("GET", payload, options.secure);
+      const id = req.params.id;
+      const singleEntity = await options.entity.findOne({
+        where: { [options.primaryKey]: _typeorm.Equal.call(void 0, id), ...secureSearchQuery },
+        select: options.returningProps
+      });
+      res.send(singleEntity);
+    } catch (err) {
+      errorCatcher(res, err, void 0, `[GET]	/:id => ${_nullishCoalesce(err.message, () => ( err))}`);
+    }
+  });
+  if (!avoidList.includes("POST")) options.router.post("/", async (req, res) => {
+    try {
+      let payload = null;
+      if (options.secure) {
+        if (_DynamicDbRouter.tokenInstance) payload = await _DynamicDbRouter.tokenInstance.authorize(req);
+        else throw new Error("Api secure option on but no token instance has been provided in the starter");
+      }
+      const secureSearchQuery = _DynamicDbRouter.setSecureParams("POST", payload, options.secure);
+      const finalBody = {};
+      const body = req.body;
+      for (const key in body) {
+        if (key !== options.primaryKey && (!options.bodyParameters || _optionalChain([options, 'access', _10 => _10.bodyParameters, 'access', _11 => _11.properties, 'optionalAccess', _12 => _12[key]]))) {
+          finalBody[key] = body[key];
+        }
+      }
+      for (const key in secureSearchQuery) {
+        finalBody[key] = secureSearchQuery[key];
+      }
+      const newEntity = await options.entity.create(finalBody).save();
+      const result = {};
+      for (const key in newEntity) {
+        if (!options.returningProps || options.returningProps.includes(key)) result[key] = newEntity[key];
+      }
+      res.send(result);
+    } catch (err) {
+      errorCatcher(res, err, void 0, `[POST]	/ => ${_nullishCoalesce(err.message, () => ( err))}`);
+    }
+  });
+  if (!avoidList.includes("PUT")) options.router.put("/:id", async (req, res) => {
+    try {
+      let payload = null;
+      if (options.secure) {
+        if (_DynamicDbRouter.tokenInstance) payload = await _DynamicDbRouter.tokenInstance.authorize(req);
+        else throw new Error("Api secure option on but no token instance has been provided in the starter");
+      }
+      const secureSearchQuery = _DynamicDbRouter.setSecureParams("PUT", payload, options.secure);
+      const id = req.params.id;
+      const body = req.body;
+      const singleEntity = await options.entity.findOneBy({ [options.primaryKey]: _typeorm.Equal.call(void 0, id) });
+      if (singleEntity === null) throw new Error("Entity not found");
+      for (const key in body) {
+        if (key !== options.primaryKey && key in singleEntity) {
+          if (!options.bodyParameters || _optionalChain([options, 'access', _13 => _13.bodyParameters, 'access', _14 => _14.properties, 'optionalAccess', _15 => _15[key]])) {
+            singleEntity[key] = body[key];
+          }
+        }
+      }
+      for (const key in secureSearchQuery) {
+        singleEntity[key] = body[key];
+      }
+      await options.entity.save(singleEntity);
+      const result = {};
+      for (const key in singleEntity) {
+        if (!options.returningProps || options.returningProps.includes(key)) result[key] = singleEntity[key];
+      }
+      res.send(result);
+    } catch (err) {
+      errorCatcher(res, err, void 0, `[PUT]	/:id => ${_nullishCoalesce(err.message, () => ( err))}`);
+    }
+  });
+  if (!avoidList.includes("DELETE")) options.router.delete("/:id", async (req, res) => {
+    try {
+      let payload = null;
+      if (options.secure) {
+        if (_DynamicDbRouter.tokenInstance) payload = await _DynamicDbRouter.tokenInstance.authorize(req);
+        else throw new Error("Api secure option on but no token instance has been provided in the starter");
+      }
+      const secureSearchQuery = _DynamicDbRouter.setSecureParams("DELETE", payload, options.secure);
+      const id = req.params.id;
+      const singleEntity = await options.entity.findOneBy({ [options.primaryKey]: _typeorm.Equal.call(void 0, id), ...secureSearchQuery });
+      if (singleEntity === null) throw new Error("Entity not found");
+      await options.entity.remove(singleEntity);
+      const result = {};
+      for (const key in singleEntity) {
+        if (!options.returningProps || options.returningProps.includes(key)) result[key] = singleEntity[key];
+      }
+      res.send(singleEntity);
+    } catch (err) {
+      errorCatcher(res, err, void 0, `[DELETE]	/:id => ${_nullishCoalesce(err.message, () => ( err))}`);
+    }
+  });
+  return options.router;
+};
+_DynamicDbRouter.addDbRouterSwagger = (options) => {
+  if (!options.primaryKey) options.primaryKey = "id";
+  const avoidList = _nullishCoalesce(options.avoid, () => ( []));
+  try {
+    let schemaProperties = {};
+    if (options.bodyParameters && options.bodyParameters) {
+      const defaultOverridingSchema = options.bodyParameters;
+      for (const param in defaultOverridingSchema.properties) {
+        const paramValue = defaultOverridingSchema.properties[param];
+        schemaProperties[param] = {
+          type: paramValue.type,
+          required: paramValue.required
+        };
+      }
+    } else {
+      const metadata = DbConnector.getDataSource().getMetadata(options.entity);
+      for (const col of metadata.columns) {
+        if (col.propertyName === options.primaryKey) continue;
+        schemaProperties[col.propertyName] = {
+          type: _DynamicDbRouter.getTypefromReflection(col.type.toString())
+        };
+      }
+    }
+    if (!avoidList.includes("POST") || !avoidList.includes("PUT")) {
+      Swagger.addSchema(options.tag, schemaProperties);
+    }
+  } catch (err) {
+    if (err instanceof _typeorm.EntityMetadataNotFoundError)
+      log.logError(`[${options.entity.name}]	Metadata required for db routing but not connected on the database`);
+  }
+  if (!avoidList.includes("LIST")) {
+    const listOptions = { page: 0, pageSize: 10, order: "ASC", orderBy: options.primaryKey };
+    Swagger.addSingleApiPath(options.tag, options.basePath, "/", "GET", [
+      ...Object.entries(listOptions).map(([key, val]) => ({ name: key, in: "query", default: val, required: false })),
+      ..._nullishCoalesce(options.getParameters, () => ( []))
+    ]);
+  }
+  if (!avoidList.includes("GET")) {
+    Swagger.addSingleApiPath(options.tag, options.basePath, `/{${options.primaryKey}}`, "GET", [
+      { name: options.primaryKey, in: "path", required: true },
+      ..._nullishCoalesce(options.getParameters, () => ( []))
+    ]);
+  }
+  if (!avoidList.includes("POST")) {
+    Swagger.addSingleApiPath(options.tag, options.basePath, "/", "POST", void 0, { schema: options.tag });
+  }
+  if (!avoidList.includes("PUT")) {
+    Swagger.addSingleApiPath(
+      options.tag,
+      options.basePath,
+      `/{${options.primaryKey}}`,
+      "PUT",
+      [{ name: options.primaryKey, in: "path", required: true }],
+      { schema: options.tag }
+    );
+  }
+  if (!avoidList.includes("DELETE")) {
+    Swagger.addSingleApiPath(options.tag, options.basePath, `/{${options.primaryKey}}`, "DELETE", [
+      { name: options.primaryKey, in: "path", required: true }
+    ]);
+  }
+};
+_DynamicDbRouter.setSecureParams = (method, payload, secure) => {
+  const searchQuery = {};
+  if (secure !== void 0 && typeof secure === "object" && payload !== null) {
+    for (const secureParam in secure) {
+      const secureParamVal = secure[secureParam];
+      if (secureParamVal.methods === "*" || secureParamVal.methods.includes(method) && payload[secureParamVal.tokenKey]) {
+        if (["LIST", "GET", "DELETE"].includes(method)) searchQuery[secureParam] = _typeorm.Equal.call(void 0, payload[secureParamVal.tokenKey]);
+        else searchQuery[secureParam] = payload[secureParamVal.tokenKey];
+      }
+    }
+  }
+  return searchQuery;
+};
+var DynamicDbRouter = _DynamicDbRouter;
+
+// src/RouterWrapper.ts
+var RouterWrapper = class {
+  constructor(data) {
+    this.createExpressRouter = () => {
+      const newRouter = _express.Router.call(void 0, );
+      if (this.data.dbRouting) {
+        const avoidOptionsForDefinedApis = [];
+        if (_optionalChain([this, 'access', _16 => _16.data, 'access', _17 => _17.apis, 'optionalAccess', _18 => _18["/"], 'optionalAccess', _19 => _19.GET])) avoidOptionsForDefinedApis.push("LIST");
+        if (_optionalChain([this, 'access', _20 => _20.data, 'access', _21 => _21.apis, 'optionalAccess', _22 => _22["/:id"], 'optionalAccess', _23 => _23.GET])) avoidOptionsForDefinedApis.push("GET");
+        if (_optionalChain([this, 'access', _24 => _24.data, 'access', _25 => _25.apis, 'optionalAccess', _26 => _26["/"], 'optionalAccess', _27 => _27.POST])) avoidOptionsForDefinedApis.push("POST");
+        if (_optionalChain([this, 'access', _28 => _28.data, 'access', _29 => _29.apis, 'optionalAccess', _30 => _30["/:id"], 'optionalAccess', _31 => _31.PUT])) avoidOptionsForDefinedApis.push("PUT");
+        if (_optionalChain([this, 'access', _32 => _32.data, 'access', _33 => _33.apis, 'optionalAccess', _34 => _34["/:id"], 'optionalAccess', _35 => _35.DELETE])) avoidOptionsForDefinedApis.push("DELETE");
+        for (const avoid of _nullishCoalesce(this.data.dbRouting.avoid, () => ( []))) {
+          if (!avoidOptionsForDefinedApis.includes(avoid)) avoidOptionsForDefinedApis.push(avoid);
+        }
+        const { entity, bodyParameters, getParameters, primaryKey, secure, returningProps } = this.data.dbRouting;
+        DynamicDbRouter.createDbRouter({
+          entity,
+          bodyParameters,
+          getParameters,
+          primaryKey,
+          router: newRouter,
+          basePath: this.data.basePath,
+          tag: this.data.tag,
+          avoid: avoidOptionsForDefinedApis,
+          secure,
+          returningProps
+        });
+      }
+      if (this.data.swaggerNewSchemas) {
+        for (const schema in this.data.swaggerNewSchemas) Swagger.addSchema(schema, this.data.swaggerNewSchemas[schema].properties);
+      }
+      for (const _path in _nullishCoalesce(this.data.apis, () => ( {}))) {
+        const path2 = _path.startsWith("/") ? _path : `/${_path}`;
+        if (!this.data.apis || !this.data.apis[path2]) continue;
+        for (const method in this.data.apis[path2]) {
+          if ((_nullishCoalesce(_optionalChain([this, 'access', _36 => _36.data, 'access', _37 => _37.apis, 'optionalAccess', _38 => _38[path2], 'optionalAccess', _39 => _39[method]]), () => ( void 0))) === void 0) continue;
+          const currentMethod = this.data.apis[path2][method];
+          const middlewares = _nullishCoalesce(currentMethod.middlewares, () => ( []));
+          const callBackFunction = async (req, res) => {
+            try {
+              const handlerRes = await currentMethod.handler(req, res);
+              if (handlerRes.contentType) {
+                res.set("Content-Type", handlerRes.contentType);
+                res.status(_nullishCoalesce(handlerRes.status, () => ( 200))).send(handlerRes.result);
+              } else if (typeof handlerRes.result === "object") res.status(handlerRes.status).json(handlerRes.result);
+              else res.status(handlerRes.status).send(handlerRes.result);
+            } catch (err) {
+              fullLogNok("api", `[${method}]	${path2} => ${_nullishCoalesce(err.message, () => ( err))}`);
+              res.status(500).send(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _40 => _40.message]), () => ( err)));
+            }
+          };
+          if (method === "GET") newRouter.get(path2, middlewares, callBackFunction);
+          else if (method === "POST") newRouter.post(path2, middlewares, callBackFunction);
+          else if (method === "PUT") newRouter.put(path2, middlewares, callBackFunction);
+          else if (method === "DELETE") newRouter.delete(path2, middlewares, callBackFunction);
+          Swagger.addSingleApiPath(
+            this.data.tag,
+            this.data.basePath,
+            path2,
+            method,
+            currentMethod.swaggerParameters,
+            currentMethod.swaggerBody,
+            currentMethod.swaggerResponses
+          );
+        }
+      }
+      if (this.data.dbRouting) {
+        const { entity, bodyParameters, getParameters, primaryKey } = this.data.dbRouting;
+        DynamicDbRouter.addDbRouterSwagger({
+          entity,
+          bodyParameters,
+          getParameters,
+          primaryKey,
+          router: newRouter,
+          basePath: this.data.basePath,
+          tag: this.data.tag,
+          avoid: this.data.dbRouting.avoid,
+          secure: _optionalChain([this, 'access', _41 => _41.data, 'access', _42 => _42.dbRouting, 'optionalAccess', _43 => _43.secure])
+        });
+      }
+      return newRouter;
+    };
+    this.data = data;
+    this.basePath = data.basePath.startsWith("/") ? data.basePath : `/${data.basePath}`;
+  }
+};
+
+// src/Starter.ts
+
+var _http = require('http'); var _http2 = _interopRequireDefault(_http);
+var _path2 = require('path'); var _path3 = _interopRequireDefault(_path2);
+var _swaggeruiexpress = require('swagger-ui-express'); var _swaggeruiexpress2 = _interopRequireDefault(_swaggeruiexpress);
+var Starter = class {
+  constructor(options) {
+    this.init = async (options) => {
+      const app = _express2.default.call(void 0, );
+      if (options.db) {
+        await this.initDb(options.projectConfig, options.db.entities, options.db.migrations, options.db.sync);
+        if (options.db.afterDbConnection) await options.db.afterDbConnection();
+      }
+      for (const plugin of _nullishCoalesce(options.plugins, () => ( []))) app.use(plugin);
+      for (const router of _nullishCoalesce(options.routers, () => ( []))) app.use(router.basePath, router.createExpressRouter());
+      if (options.swagger === void 0 || options.swagger) {
+        Swagger.addServer({ url: `http://127.0.0.1:${options.projectConfig.SERVER_PORT}` });
+        app.get("/swagger", (_, res) => {
+          const openAPIDocument = Swagger.generateOpenAPIDocument();
+          res.json(openAPIDocument);
+        });
+        app.use("/swagger-ui", _swaggeruiexpress2.default.serve, _swaggeruiexpress2.default.setup(void 0, {
+          swaggerOptions: {
+            url: "/swagger"
+          }
+        }));
+      }
+      if (options.tokenOptions) DynamicDbRouter.setTokenInstance(options.tokenOptions.tokenInstance);
+      if (options.clientPath) {
+        const clientPath = _path3.default.resolve(process.cwd(), "client");
+        app.use(_express2.default.static(clientPath));
+        app.get("/apiUrl", (_, res) => res.send(options.projectConfig.API_URL));
+        if (_optionalChain([options, 'access', _44 => _44.tokenOptions, 'optionalAccess', _45 => _45.api])) {
+          app.get(_nullishCoalesce(options.tokenOptions.api.path, () => ( "/api/auth")), options.tokenOptions.api.callback);
+        }
+        app.get("*", (_, res) => {
+          res.sendFile(_path3.default.join(clientPath, "index.html"));
+        });
+      }
+      if (options.socket === void 0 || options.socket === false) {
+        if (options.beforeStartListening) options.beforeStartListening(app);
+        app.listen(options.projectConfig.SERVER_PORT, () => log.base("Server started.", `Listening on port ${options.projectConfig.SERVER_PORT}`));
+      } else if (options.socket === true) {
+        const server = _http2.default.createServer(app);
+        if (options.beforeStartListening) options.beforeStartListening(app, server);
+        server.listen(options.projectConfig.SERVER_PORT, () => log.base("Server started.", `Listening on port ${options.projectConfig.SERVER_PORT}`));
+      }
+    };
+    this.initDb = async (projectConfig, entities, migrations, sync) => {
+      const connector = new DbConnector(projectConfig);
+      await connector.connect(entities, migrations, sync);
+    };
+    try {
+      log.setFilePath(options.projectConfig.ERROR_FILE_PATH);
+      this.init(options);
+    } catch (err) {
+      log.logError(err);
+    }
+  }
+};
+
+// src/Token.ts
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+var _nodejose = require('node-jose'); var _nodejose2 = _interopRequireDefault(_nodejose);
+var Token = class {
+  constructor(tokenPayload) {
+    this.keyStore = null;
+    // Metodo per autorizzare una richiesta
+    this.authorize = async (req) => {
+      const token = _nullishCoalesce(_optionalChain([req, 'access', _46 => _46.headers, 'access', _47 => _47.authorization, 'optionalAccess', _48 => _48.split, 'call', _49 => _49("Bearer "), 'optionalAccess', _50 => _50[1]]), () => ( null));
+      if (token === null) throw new Error("UNAUTH");
+      const payload = await this.verifyJWE(token);
+      return payload;
+    };
+    if (!tokenPayload.SECRET_KEY) throw new Error("SECRET_KEY is required if you want to use the Token Class");
+    this.SECRET_KEY = tokenPayload.SECRET_KEY;
+    this.ExpTime = tokenPayload.ExpTime;
+    this.EncAlgorithm = tokenPayload.EncAlgorithm;
+    this.KeyLength = tokenPayload.KeyLength;
+  }
+  // Inizializza la KeyStore
+  async getKey() {
+    if (!this.keyStore) {
+      this.keyStore = _nodejose2.default.JWK.createKeyStore();
+      const encryptionKey = this.deriveEncryptionKey();
+      const key = await _nodejose2.default.JWK.asKey({
+        kty: "oct",
+        k: _nodejose2.default.util.base64url.encode(encryptionKey)
+      });
+      await this.keyStore.add(key);
+    }
+    return this.keyStore.all({ use: "enc" })[0];
+  }
+  // Metodo per derivare chiave di cifratura
+  deriveEncryptionKey() {
+    return _crypto2.default.createHash("sha256").update(this.SECRET_KEY).digest().slice(0, this.KeyLength);
+  }
+  // Metodo per generare token cifrato (JWE)
+  async generateJWE(payload) {
+    const key = await this.getKey();
+    const input = Buffer.from(JSON.stringify({
+      ...payload,
+      iat: Math.floor(Date.now() / 1e3),
+      exp: Math.floor(Date.now() / 1e3) + this.ExpTime
+    }));
+    const jwe = await _nodejose2.default.JWE.createEncrypt({
+      format: "compact",
+      fields: { alg: "dir", enc: this.EncAlgorithm }
+    }, key).update(input).final();
+    return jwe;
+  }
+  // Metodo per decifrare token JWE
+  async verifyJWE(token) {
+    try {
+      const key = await this.getKey();
+      const result = await _nodejose2.default.JWE.createDecrypt(key).decrypt(token);
+      const payload = JSON.parse(result.plaintext.toString());
+      const now = Math.floor(Date.now() / 1e3);
+      if (payload.exp && payload.exp < now) {
+        throw new Error("Token expired");
+      }
+      return payload;
+    } catch (error) {
+      throw new Error("Token decryption failed");
+    }
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+exports.RouterWrapper = RouterWrapper; exports.Starter = Starter; exports.Swagger = Swagger; exports.Token = Token; exports.apiNok = apiNok; exports.apiOk = apiOk; exports.errorCatcher = errorCatcher; exports.fullLogNok = fullLogNok; exports.fullLogOk = fullLogOk; exports.log = log;