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

package/dist/index.mjs

@@ -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: 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 path3 = `${basePath}${_path}`;
-    if (options[_path].get?.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 = 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];
-        }
+import { ExpressoSwagger } from "expresso-swagger";
+var MySwagger = class extends 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: 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 ?? {}
+  /**
+   * 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 options.getParameters ?? []) {
-        const val = 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(options.getParameters ?? {})) {
+        const val = 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] = Like(`%${val}%`);
-          else searchQuery[param.name] = Equal(val);
+          if (param.like) searchQuery[key] = Like(`%${val}%`);
+          else searchQuery[key] = Equal(val);
         }
       }
       const secureSearchQuery = _DynamicDbRouter.setSecureParams("LIST", payload, options.secure);
@@ -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 })),
-      ...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" })),
+        ...options.getParameters ?? []
+      ]
+    });
   }
   if (!avoidList.includes("GET")) {
-    Swagger.addSingleApiPath(options.tag, options.basePath, `/{${options.primaryKey}}`, "GET", [
-      { name: options.primaryKey, in: "path", required: true },
-      ...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" },
+        ...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) => {
@@ -637,7 +455,7 @@ var RouterWrapper = class {
         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;
+        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) {
@@ -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
+            }
           );
         }
       }
@@ -810,10 +632,10 @@ var SocketWrapper = class {
 
 // src/Starter.ts
 import express from "express";
+import { getUIPath } from "expresso-swagger";
 import http from "http";
 import path2 from "path";
 import { Server } from "socket.io";
-import swaggerUi from "swagger-ui-express";
 var Starter = class {
   constructor(options) {
     this.init = async (options) => {
@@ -827,17 +649,12 @@ 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", swaggerUi.serve, swaggerUi.setup(void 0, {
-          swaggerOptions: {
-            url: "/swagger"
-          }
-        }));
-        swaggerLogs = [`Swagger docs available at ${swaggerUrl}/swagger`, `Swagger UI available at ${swaggerUrl}/swagger-ui`];
+        app.use("/docs-ui", express.static(getUIPath()));
+        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) {
@@ -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 = req.headers.cookie ?? "";
       const cookies = parse(rawCookies);
       const cookieToken = cookies[this.TOKEN_COOKIE_NAME] ?? null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expresso-macchiato",
-  "version": "1.0.0-dev.7",
+  "version": "1.0.0-dev.9",
   "author": "Alessio Velluso",
   "license": "MIT",
   "description": "Description",
@@ -33,13 +33,12 @@
     "cors": "^2.8.5",
     "dotenv": "^16.3.1",
     "express": "^4.18.2",
+    "expresso-swagger": "^0.0.8",
     "jsonwebtoken": "^9.0.2",
     "multer": "^1.4.5-lts.1",
     "node-jose": "^2.2.0",
     "reflect-metadata": "^0.2.2",
     "socket.io": "^4.8.1",
-    "swagger-jsdoc": "^6.2.8",
-    "swagger-ui-express": "^5.0.1",
     "utils-logger-av": "^4.0.0",
     "utils-stuff": "^4.5.0"
   },

package/types/db.sptypes.ts

@@ -1,7 +1,8 @@
 import { Router } from "express"
+import { ExpressoSwaggerModel } from "expresso-swagger"
 import { BaseEntity } from "typeorm"
+import { CustomSwaggerParameter } from "../src/Swagger"
 import { Methods } from "./generic.sptypes"
-import { Parameter, SchemaV3 } from "./swagger.sptypes"
 import { SecureTokenConfig } from "./token.sptypes"
 
 export type DynamicDbRouterOptions<T extends typeof BaseEntity> = {
@@ -10,9 +11,10 @@ export type DynamicDbRouterOptions<T extends typeof BaseEntity> = {
     primaryKey?:string,
     tag:string
     basePath:string,
-    getParameters?:Array<Parameter>
-    bodyParameters?:SchemaV3
+    getParameters?:Array<CustomSwaggerParameter>,
+    bodyParameters?:ExpressoSwaggerModel
     avoid?:Array<Methods | 'LIST'>,
     secure?:SecureTokenConfig,
-    returningProps?:string[]
+    returningProps?:string[],
+    responses?:Record<string | number, { description: string, body?: any }>
 }

package/types/router.sptypes.ts

@@ -1,21 +1,24 @@
 import { Response as ExpressResponse, Request, RequestHandler } from "express";
+import { ExpressoSwaggerModel } from "expresso-swagger";
 import { BaseEntity } from "typeorm";
+import { CustomSwaggerParameter } from "../src/Swagger";
+import { DynamicDbRouterOptions } from "./db.sptypes";
 import { ExpressReturn, Methods } from "./generic.sptypes";
-import { Parameter, Reference, SchemaV3, Response as SwaggerResponse } from "./swagger.sptypes";
 import { SecureTokenConfig } from "./token.sptypes";
 
 export interface RouterWrapperInterface<T extends typeof BaseEntity = typeof BaseEntity> {
     basePath:string;
     tag:string,
-    swaggerNewSchemas?:{ [schema:string]: SchemaV3 },
+    swaggerNewSchemas?:{ [schema:string]: ExpressoSwaggerModel },
     dbRouting?:{
         entity:T,
         primaryKey?:string,
-        getParameters?:Array<Parameter>
-        bodyParameters?:SchemaV3,
+        getParameters?:Array<CustomSwaggerParameter>
+        bodyParameters?:ExpressoSwaggerModel,
         avoid?:Array<Methods | 'LIST'>,
         secure?:SecureTokenConfig,
-        returningProps?:string[]
+        returningProps?:string[],
+        responses?:Record<string | number, { description: string, body?: any }>
     }
     apis?: Record<string, {
         'GET'?:MethodPathHandling
@@ -32,8 +35,8 @@ export type MethodPathHandling = {
         description?:string,
         comType?:'application/json' | 'multipart/form-data',
     },
-    swaggerResponses?:Record<string, Reference | SwaggerResponse>,
-    swaggerParameters?:Array<Parameter>
+    swaggerResponses?:DynamicDbRouterOptions<any>['responses'],
+    swaggerParameters?:Array<CustomSwaggerParameter>
     middlewares?: RequestHandler[];
     handler: (req:Request, res:ExpressResponse) => Promise<ExpressReturn>
 }