expresso-macchiato 0.3.0

package/dist/index.mjs

@@ -0,0 +1,825 @@
+// src/RouterWrapper.ts
+import { Router } from "express";
+
+// src/_utils.ts
+import { Logger } from "utils-logger-av";
+var MyLogger = class extends 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 = error?.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 = (errorsList ?? {})[err.message] ?? null;
+  if (!error) res.status(500).send({ message: err.message });
+  else res.status(error.status ?? 500).send({ message: error.responseMessage ?? err.message });
+};
+
+// src/DynamicDbRouter.ts
+import { EntityMetadataNotFoundError, Equal, Like } from "typeorm";
+
+// src/DbConnector.ts
+import "reflect-metadata";
+import { DataSource } from "typeorm";
+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 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: sync ?? false,
+          logging: false,
+          migrations
+        });
+        await AppDataSource.initialize();
+        if (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: bodyObj.required ?? false,
+    description: bodyObj.description,
+    content: {
+      [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 (options[_path].get?.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 = 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: options?.page ?? 0,
+    pageSize: options?.pageSize ?? 10,
+    order: options?.order ?? "ASC",
+    orderBy: options?.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" },
+    ...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) => _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 = 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 options.getParameters ?? []) {
+        const val = 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] = Like(`%${val}%`);
+          else searchQuery[param.name] = Equal(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: pageSize ?? 0,
+        skip: (page ?? 0) * (pageSize ?? 0),
+        order: { [orderBy ?? options.primaryKey]: order ?? "ASC" },
+        select: options.returningProps
+      });
+      res.send(entities);
+    } catch (err) {
+      errorCatcher(res, err, void 0, `[GET]	/ => ${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]: Equal(id), ...secureSearchQuery },
+        select: options.returningProps
+      });
+      res.send(singleEntity);
+    } catch (err) {
+      errorCatcher(res, err, void 0, `[GET]	/:id => ${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 || options.bodyParameters.properties?.[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]	/ => ${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]: Equal(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 || options.bodyParameters.properties?.[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 => ${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]: Equal(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 => ${err.message ?? err}`);
+    }
+  });
+  return options.router;
+};
+_DynamicDbRouter.addDbRouterSwagger = (options) => {
+  if (!options.primaryKey) options.primaryKey = "id";
+  const avoidList = 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 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 })),
+      ...options.getParameters ?? []
+    ]);
+  }
+  if (!avoidList.includes("GET")) {
+    Swagger.addSingleApiPath(options.tag, options.basePath, `/{${options.primaryKey}}`, "GET", [
+      { name: options.primaryKey, in: "path", required: true },
+      ...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] = Equal(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 = Router();
+      if (this.data.dbRouting) {
+        const avoidOptionsForDefinedApis = [];
+        if (this.data.apis?.["/"]?.GET) avoidOptionsForDefinedApis.push("LIST");
+        if (this.data.apis?.["/:id"]?.GET) avoidOptionsForDefinedApis.push("GET");
+        if (this.data.apis?.["/"]?.POST) avoidOptionsForDefinedApis.push("POST");
+        if (this.data.apis?.["/:id"]?.PUT) avoidOptionsForDefinedApis.push("PUT");
+        if (this.data.apis?.["/:id"]?.DELETE) avoidOptionsForDefinedApis.push("DELETE");
+        for (const avoid of 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 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 ((this.data.apis?.[path2]?.[method] ?? void 0) === void 0) continue;
+          const currentMethod = this.data.apis[path2][method];
+          const middlewares = 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(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} => ${err.message ?? err}`);
+              res.status(500).send(err?.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: this.data.dbRouting?.secure
+        });
+      }
+      return newRouter;
+    };
+    this.data = data;
+    this.basePath = data.basePath.startsWith("/") ? data.basePath : `/${data.basePath}`;
+  }
+};
+
+// src/Starter.ts
+import express from "express";
+import http from "http";
+import path from "path";
+import swaggerUi from "swagger-ui-express";
+var Starter = class {
+  constructor(options) {
+    this.init = async (options) => {
+      const app = express();
+      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 options.plugins ?? []) app.use(plugin);
+      for (const router of 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", swaggerUi.serve, swaggerUi.setup(void 0, {
+          swaggerOptions: {
+            url: "/swagger"
+          }
+        }));
+      }
+      if (options.tokenOptions) DynamicDbRouter.setTokenInstance(options.tokenOptions.tokenInstance);
+      if (options.clientPath) {
+        const clientPath = path.resolve(process.cwd(), "client");
+        app.use(express.static(clientPath));
+        app.get("/apiUrl", (_, res) => res.send(options.projectConfig.API_URL));
+        if (options.tokenOptions?.api) {
+          app.get(options.tokenOptions.api.path ?? "/api/auth", options.tokenOptions.api.callback);
+        }
+        app.get("*", (_, res) => {
+          res.sendFile(path.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 = http.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
+import crypto from "crypto";
+import jose from "node-jose";
+var Token = class {
+  constructor(tokenPayload) {
+    this.keyStore = null;
+    // Metodo per autorizzare una richiesta
+    this.authorize = async (req) => {
+      const token = req.headers.authorization?.split("Bearer ")?.[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 = jose.JWK.createKeyStore();
+      const encryptionKey = this.deriveEncryptionKey();
+      const key = await jose.JWK.asKey({
+        kty: "oct",
+        k: jose.util.base64url.encode(encryptionKey)
+      });
+      await this.keyStore.add(key);
+    }
+    return this.keyStore.all({ use: "enc" })[0];
+  }
+  // Metodo per derivare chiave di cifratura
+  deriveEncryptionKey() {
+    return crypto.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 jose.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 jose.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");
+    }
+  }
+};
+export {
+  RouterWrapper,
+  Starter,
+  Swagger,
+  Token,
+  apiNok,
+  apiOk,
+  errorCatcher,
+  fullLogNok,
+  fullLogOk,
+  log
+};