expresso-macchiato 1.0.0-dev.7 → 1.0.0-dev.9

package/dist/index.js

@@ -114,267 +114,68 @@ _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 path3 = `${_Swagger.fromExpressParamsToSwagger(basePath)}${_Swagger.fromExpressParamsToSwagger(_path)}`;
-  const transcribedMethod = _Swagger.restMethodToSwaggerKeyMapping[method];
-  if (!_Swagger.apiDocument.paths[path3]) _Swagger.apiDocument.paths[path3] = {};
-  if (_Swagger.apiDocument.paths[path3][transcribedMethod]) return;
-  _Swagger.apiDocument.paths[path3][transcribedMethod] = {
-    responses,
-    parameters,
-    tags: [tag]
-  };
-  if (bodyObj) _Swagger.apiDocument.paths[path3][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 path3 = `${basePath}${_path}`;
-    if (_optionalChain([options, 'access', _4 => _4[_path], 'access', _5 => _5.get, 'optionalAccess', _6 => _6.tags])) options[_path].get.tags = [tag];
-    finalPaths[path3] = {
-      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[path3].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[path3].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[path3].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[path3].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];
-        }
+var _expressoswagger = require('expresso-swagger');
+var MySwagger = class extends _expressoswagger.ExpressoSwagger {
+  constructor() {
+    super({
+      info: {
+        title: "Expresso Macchiato API",
+        version: "1.0.0",
+        description: "API documentation for Expresso Macchiato"
+      },
+      settings: {
+        theme: "dark",
+        withCredentials: true
       }
-    }
+    });
+    this.fromExpressParamsToSwagger = (str) => str.replace(/:(\w+)(?=\/|$)/g, "{$1}");
   }
-  for (const path3 in finalPaths) {
-    for (const method in finalPaths[path3]) {
-      const methodKey = method;
-      if (!_Swagger.apiDocument.paths[path3]) _Swagger.apiDocument.paths[path3] = {};
-      if (!_Swagger.apiDocument.paths[path3][methodKey]) _Swagger.apiDocument.paths[path3][methodKey] = finalPaths[path3][methodKey];
-    }
+  setBaseUrl(url) {
+    this.config.baseUrl = url;
   }
-  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];
+  addSchema(name, schema) {
+    if (!this.config.models) this.config.models = {};
+    this.config.models[name] = 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', _7 => _7.page]), () => ( 0)),
-    pageSize: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.pageSize]), () => ( 10)),
-    order: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.order]), () => ( "ASC")),
-    orderBy: _optionalChain([options, 'optionalAccess', _10 => _10.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, () => ( {}))
+  /**
+   * Adds a single API path by accumulating it into the internal list.
+   */
+  addSingleApiPath(group, basePath, _path, method, options) {
+    const fullPath = this.fromExpressParamsToSwagger(`${basePath}${_path}`);
+    const params = {};
+    const query = {};
+    if (options.parameters) {
+      options.parameters.forEach((p) => {
+        const def = { type: p.type || "string", required: p.required, description: p.description, default: p.default };
+        if (p.in === "path") params[p.name] = def;
+        if (p.in === "query") query[p.name] = def;
+      });
+    }
+    this.endpoints.push({
+      path: fullPath,
+      method,
+      group,
+      name: options.name,
+      description: options.description,
+      params: Object.keys(params).length > 0 ? params : void 0,
+      query: Object.keys(query).length > 0 ? query : void 0,
+      body: options.body,
+      responses: options.responses
+    });
   }
-});
-/**
- * @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];
+  /**
+   * Instantiates ExpressoSwagger and generates the final document.
+   */
+  generateDocument() {
+    return this.getDocument();
   }
-  return finalSchemaObject;
 };
-var Swagger = _Swagger;
+MySwagger.getIdParam = (name = "id") => ({ name, in: "path", required: true, type: "string", description: `Unique identifier.` });
+MySwagger.getPaginationParams = () => [
+  { name: "page", in: "query", type: "number", default: 1 },
+  { name: "limit", in: "query", type: "number", default: 10 }
+];
+var Swagger = new MySwagger();
 
 // src/DynamicDbRouter.ts
 var _DynamicDbRouter = class _DynamicDbRouter {
@@ -422,12 +223,12 @@ _DynamicDbRouter.createDbRouter = (options) => {
         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`);
+      for (const [key, param] of Object.entries(_nullishCoalesce(options.getParameters, () => ( {})))) {
+        const val = _nullishCoalesce(req.query[key], () => ( void 0));
+        if (param.required && !val) throw new Error(`Params Error: ${key} 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);
+          if (param.like) searchQuery[key] = _typeorm.Like.call(void 0, `%${val}%`);
+          else searchQuery[key] = _typeorm.Equal.call(void 0, val);
         }
       }
       const secureSearchQuery = _DynamicDbRouter.setSecureParams("LIST", payload, options.secure);
@@ -473,7 +274,7 @@ _DynamicDbRouter.createDbRouter = (options) => {
       const finalBody = {};
       const body = req.body;
       for (const key in body) {
-        if (key !== options.primaryKey && (!options.bodyParameters || _optionalChain([options, 'access', _11 => _11.bodyParameters, 'access', _12 => _12.properties, 'optionalAccess', _13 => _13[key]]))) {
+        if (key !== options.primaryKey && (!options.bodyParameters || _optionalChain([options, 'access', _4 => _4.bodyParameters, 'access', _5 => _5.properties, 'optionalAccess', _6 => _6[key]]))) {
           finalBody[key] = body[key];
         }
       }
@@ -504,7 +305,7 @@ _DynamicDbRouter.createDbRouter = (options) => {
       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', _14 => _14.bodyParameters, 'access', _15 => _15.properties, 'optionalAccess', _16 => _16[key]])) {
+          if (!options.bodyParameters || _optionalChain([options, 'access', _7 => _7.bodyParameters, 'access', _8 => _8.properties, 'optionalAccess', _9 => _9[key]])) {
             singleEntity[key] = body[key];
           }
         }
@@ -577,19 +378,28 @@ _DynamicDbRouter.addDbRouterSwagger = (options) => {
   }
   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, () => ( []))
-    ]);
+    Swagger.addSingleApiPath(options.tag, options.basePath, "/", "GET", {
+      name: "/",
+      responses: options.responses,
+      parameters: [
+        { name: "page", in: "query", type: "number", default: 0, required: false },
+        ...Object.entries(listOptions).map(([key, val]) => ({ name: key, in: "query", default: val, required: false, type: typeof val === "number" ? "number" : "string" })),
+        ..._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, () => ( []))
-    ]);
+    Swagger.addSingleApiPath(options.tag, options.basePath, `/{${options.primaryKey}}`, "GET", {
+      name: `/{${options.primaryKey}}`,
+      responses: options.responses,
+      parameters: [
+        { name: options.primaryKey, in: "path", required: true, type: "string" },
+        ..._nullishCoalesce(options.getParameters, () => ( []))
+      ]
+    });
   }
   if (!avoidList.includes("POST")) {
-    Swagger.addSingleApiPath(options.tag, options.basePath, "/", "POST", void 0, { schema: options.tag });
+    Swagger.addSingleApiPath(options.tag, options.basePath, "/", "POST", { body: options.tag, responses: options.responses });
   }
   if (!avoidList.includes("PUT")) {
     Swagger.addSingleApiPath(
@@ -597,14 +407,22 @@ _DynamicDbRouter.addDbRouterSwagger = (options) => {
       options.basePath,
       `/{${options.primaryKey}}`,
       "PUT",
-      [{ name: options.primaryKey, in: "path", required: true }],
-      { schema: options.tag }
+      {
+        name: `/{${options.primaryKey}}`,
+        body: options.tag,
+        parameters: [{ name: options.primaryKey, in: "path", required: true, type: "string" }],
+        responses: options.responses
+      }
     );
   }
   if (!avoidList.includes("DELETE")) {
-    Swagger.addSingleApiPath(options.tag, options.basePath, `/{${options.primaryKey}}`, "DELETE", [
-      { name: options.primaryKey, in: "path", required: true }
-    ]);
+    Swagger.addSingleApiPath(options.tag, options.basePath, `/{${options.primaryKey}}`, "DELETE", {
+      name: `/{${options.primaryKey}}`,
+      responses: options.responses,
+      parameters: [
+        { name: options.primaryKey, in: "path", required: true, type: "string" }
+      ]
+    });
   }
 };
 _DynamicDbRouter.setSecureParams = (method, payload, secure) => {
@@ -629,15 +447,15 @@ var RouterWrapper = class {
       const newRouter = _express.Router.call(void 0, );
       if (this.data.dbRouting) {
         const avoidOptionsForDefinedApis = [];
-        if (_optionalChain([this, 'access', _17 => _17.data, 'access', _18 => _18.apis, 'optionalAccess', _19 => _19["/"], 'optionalAccess', _20 => _20.GET])) avoidOptionsForDefinedApis.push("LIST");
-        if (_optionalChain([this, 'access', _21 => _21.data, 'access', _22 => _22.apis, 'optionalAccess', _23 => _23["/:id"], 'optionalAccess', _24 => _24.GET])) avoidOptionsForDefinedApis.push("GET");
-        if (_optionalChain([this, 'access', _25 => _25.data, 'access', _26 => _26.apis, 'optionalAccess', _27 => _27["/"], 'optionalAccess', _28 => _28.POST])) avoidOptionsForDefinedApis.push("POST");
-        if (_optionalChain([this, 'access', _29 => _29.data, 'access', _30 => _30.apis, 'optionalAccess', _31 => _31["/:id"], 'optionalAccess', _32 => _32.PUT])) avoidOptionsForDefinedApis.push("PUT");
-        if (_optionalChain([this, 'access', _33 => _33.data, 'access', _34 => _34.apis, 'optionalAccess', _35 => _35["/:id"], 'optionalAccess', _36 => _36.DELETE])) avoidOptionsForDefinedApis.push("DELETE");
+        if (_optionalChain([this, 'access', _10 => _10.data, 'access', _11 => _11.apis, 'optionalAccess', _12 => _12["/"], 'optionalAccess', _13 => _13.GET])) avoidOptionsForDefinedApis.push("LIST");
+        if (_optionalChain([this, 'access', _14 => _14.data, 'access', _15 => _15.apis, 'optionalAccess', _16 => _16["/:id"], 'optionalAccess', _17 => _17.GET])) avoidOptionsForDefinedApis.push("GET");
+        if (_optionalChain([this, 'access', _18 => _18.data, 'access', _19 => _19.apis, 'optionalAccess', _20 => _20["/"], 'optionalAccess', _21 => _21.POST])) avoidOptionsForDefinedApis.push("POST");
+        if (_optionalChain([this, 'access', _22 => _22.data, 'access', _23 => _23.apis, 'optionalAccess', _24 => _24["/:id"], 'optionalAccess', _25 => _25.PUT])) avoidOptionsForDefinedApis.push("PUT");
+        if (_optionalChain([this, 'access', _26 => _26.data, 'access', _27 => _27.apis, 'optionalAccess', _28 => _28["/:id"], 'optionalAccess', _29 => _29.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;
+        const { entity, bodyParameters, getParameters, primaryKey, secure, returningProps, responses } = this.data.dbRouting;
         DynamicDbRouter.createDbRouter({
           entity,
           bodyParameters,
@@ -648,7 +466,8 @@ var RouterWrapper = class {
           tag: this.data.tag,
           avoid: avoidOptionsForDefinedApis,
           secure,
-          returningProps
+          returningProps,
+          responses
         });
       }
       if (this.data.swaggerNewSchemas) {
@@ -658,7 +477,7 @@ var RouterWrapper = class {
         const path3 = _path.startsWith("/") ? _path : `/${_path}`;
         if (!this.data.apis || !this.data.apis[path3]) continue;
         for (const method in this.data.apis[path3]) {
-          if ((_nullishCoalesce(_optionalChain([this, 'access', _37 => _37.data, 'access', _38 => _38.apis, 'optionalAccess', _39 => _39[path3], 'optionalAccess', _40 => _40[method]]), () => ( void 0))) === void 0) continue;
+          if ((_nullishCoalesce(_optionalChain([this, 'access', _30 => _30.data, 'access', _31 => _31.apis, 'optionalAccess', _32 => _32[path3], 'optionalAccess', _33 => _33[method]]), () => ( void 0))) === void 0) continue;
           const currentMethod = this.data.apis[path3][method];
           const middlewares = _nullishCoalesce(currentMethod.middlewares, () => ( []));
           const callBackFunction = async (req, res) => {
@@ -671,7 +490,7 @@ var RouterWrapper = class {
               else res.status(handlerRes.status).send(handlerRes.result);
             } catch (err) {
               fullLogNok("api", `[${method}] ${this.data.basePath}${path3} => ${_nullishCoalesce(err.message, () => ( err))}`);
-              res.status(500).send(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _41 => _41.message]), () => ( err)));
+              res.status(500).send(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _34 => _34.message]), () => ( err)));
             }
           };
           if (method === "GET") newRouter.get(path3, middlewares, callBackFunction);
@@ -683,9 +502,12 @@ var RouterWrapper = class {
             this.data.basePath,
             path3,
             method,
-            currentMethod.swaggerParameters,
-            currentMethod.swaggerBody,
-            currentMethod.swaggerResponses
+            {
+              name: path3,
+              parameters: currentMethod.swaggerParameters,
+              body: currentMethod.swaggerBody ? currentMethod.swaggerBody.schema : void 0,
+              responses: currentMethod.swaggerResponses
+            }
           );
         }
       }
@@ -700,7 +522,7 @@ var RouterWrapper = class {
           basePath: this.data.basePath,
           tag: this.data.tag,
           avoid: this.data.dbRouting.avoid,
-          secure: _optionalChain([this, 'access', _42 => _42.data, 'access', _43 => _43.dbRouting, 'optionalAccess', _44 => _44.secure])
+          secure: _optionalChain([this, 'access', _35 => _35.data, 'access', _36 => _36.dbRouting, 'optionalAccess', _37 => _37.secure])
         });
       }
       return newRouter;
@@ -734,10 +556,10 @@ var SocketWrapper = class {
           try {
             if (!this.namespace) throw new Error("Socket.IO not initialized");
             const metadata = client.handshake.query.metadata;
-            const finalClientId = this.data.clientConnectionKey ? _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _45 => _45[this.data.clientConnectionKey]]), () => ( client.id)) : client.id;
+            const finalClientId = this.data.clientConnectionKey ? _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _38 => _38[this.data.clientConnectionKey]]), () => ( client.id)) : client.id;
             this.connectedClients.set(finalClientId, { socket: client, connectedAt: /* @__PURE__ */ new Date(), metadata });
             if (this.data.afterClientConnect) this.data.afterClientConnect(this, client, metadata);
-            for (const eventName in _nullishCoalesce(this.data.listeners, () => ( []))) client.on(eventName, (...params) => _optionalChain([this, 'access', _46 => _46.data, 'access', _47 => _47.listeners, 'optionalAccess', _48 => _48[eventName], 'call', _49 => _49(this, client, metadata, ...params)]));
+            for (const eventName in _nullishCoalesce(this.data.listeners, () => ( []))) client.on(eventName, (...params) => _optionalChain([this, 'access', _39 => _39.data, 'access', _40 => _40.listeners, 'optionalAccess', _41 => _41[eventName], 'call', _42 => _42(this, client, metadata, ...params)]));
             client.on("disconnect", () => this.handleDisconnection(finalClientId));
           } catch (err) {
             fullLogNok(`SOCKETWRAPPER`, `[${this.socketNamespace.toUpperCase()}]`, err);
@@ -803,17 +625,17 @@ var SocketWrapper = class {
     this.socketNamespace = data.socketNamespace;
     this.data = data;
     Object.keys(_nullishCoalesce(data.listeners, () => ( {}))).forEach((key) => {
-      this[key] = _optionalChain([data, 'access', _50 => _50.listeners, 'optionalAccess', _51 => _51[key], 'access', _52 => _52.bind, 'call', _53 => _53(this)]);
+      this[key] = _optionalChain([data, 'access', _43 => _43.listeners, 'optionalAccess', _44 => _44[key], 'access', _45 => _45.bind, 'call', _46 => _46(this)]);
     });
   }
 };
 
 // src/Starter.ts
 
+
 var _http = require('http'); var _http2 = _interopRequireDefault(_http);
 
 var _socketio = require('socket.io');
-var _swaggeruiexpress = require('swagger-ui-express'); var _swaggeruiexpress2 = _interopRequireDefault(_swaggeruiexpress);
 var Starter = class {
   constructor(options) {
     this.init = async (options) => {
@@ -827,24 +649,19 @@ var Starter = class {
       let swaggerLogs = null;
       if (options.swagger === void 0 || options.swagger) {
         const swaggerUrl = `http://127.0.0.1:${options.projectConfig.SERVER_PORT}`;
-        Swagger.addServer({ url: swaggerUrl });
-        app.get("/swagger", (_, res) => {
-          const openAPIDocument = Swagger.generateOpenAPIDocument();
-          res.json(openAPIDocument);
+        Swagger.setBaseUrl(swaggerUrl);
+        app.get("/docs", (_, res) => {
+          res.json(Swagger.generateDocument());
         });
-        app.use("/swagger-ui", _swaggeruiexpress2.default.serve, _swaggeruiexpress2.default.setup(void 0, {
-          swaggerOptions: {
-            url: "/swagger"
-          }
-        }));
-        swaggerLogs = [`Swagger docs available at ${swaggerUrl}/swagger`, `Swagger UI available at ${swaggerUrl}/swagger-ui`];
+        app.use("/docs-ui", _express2.default.static(_expressoswagger.getUIPath.call(void 0, )));
+        swaggerLogs = [`Swagger docs available at ${swaggerUrl}/docs`, `Swagger UI available at ${swaggerUrl}/docs-ui`];
       }
       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', _54 => _54.tokenOptions, 'optionalAccess', _55 => _55.api])) {
+        if (_optionalChain([options, 'access', _47 => _47.tokenOptions, 'optionalAccess', _48 => _48.api])) {
           app.get(_nullishCoalesce(options.tokenOptions.api.path, () => ( "/api/auth")), options.tokenOptions.api.callback);
         }
         app.get("*", (_, res) => {
@@ -904,9 +721,12 @@ var Token = class {
     }
     return this.keyStore.all({ use: "enc" })[0];
   }
-  // Metodo per autorizzare una richiesta
+  // Metodo per autorizzare una richiesta (string is for sockets implementations outside this package)
   async authorize(req) {
-    if (this.TOKEN_COOKIE_NAME) {
+    if (typeof req === "string") {
+      const payload = await this.verifyJWE(req);
+      return payload;
+    } else if (this.TOKEN_COOKIE_NAME) {
       const rawCookies = _nullishCoalesce(req.headers.cookie, () => ( ""));
       const cookies = _cookie.parse.call(void 0, rawCookies);
       const cookieToken = _nullishCoalesce(cookies[this.TOKEN_COOKIE_NAME], () => ( null));
@@ -914,7 +734,7 @@ var Token = class {
       const payload = await this.verifyJWE(cookieToken);
       return payload;
     } else {
-      const token = _nullishCoalesce(_optionalChain([req, 'access', _56 => _56.headers, 'access', _57 => _57.authorization, 'optionalAccess', _58 => _58.split, 'call', _59 => _59("Bearer "), 'optionalAccess', _60 => _60[1]]), () => ( null));
+      const token = _nullishCoalesce(_optionalChain([req, 'access', _49 => _49.headers, 'access', _50 => _50.authorization, 'optionalAccess', _51 => _51.split, 'call', _52 => _52("Bearer "), 'optionalAccess', _53 => _53[1]]), () => ( null));
       if (token === null) throw new Error("UNAUTH");
       const payload = await this.verifyJWE(token);
       return payload;