c2-http 0.0.1

package/src/flow/authorization/MiddlewareCheckRolesFlow.ts

@@ -0,0 +1,47 @@
+import { NextFunction, Request, Response } from "express"
+import httpContext from "express-http-context"
+import { UNAUTHORIZED } from "http-status"
+import { rolesFullAcess } from "../../config/contants"
+import { getMessage } from "../../config/i18n"
+import HttpError from "../../model/HttpError"
+import { isEmpty, isNotEmpty } from "../../utils/Utils"
+import HttpJsonDispatchErrorFlow from "../dispatcher/HttpJsonDispatchErrorFlow"
+
+class MiddlewareCheckRolesFlow {
+    public middleware = (...roles: string[]) => {
+        return (request: Request, response: Response, next: NextFunction) => {
+
+            try {
+                this.mustRoles([...rolesFullAcess, ...roles], request, response, next)
+                next()
+            } catch (error: any) {
+                HttpJsonDispatchErrorFlow.dispatch(response, error)
+            }
+        }
+    }
+
+
+
+    public mustRoles = (roles: string[], request: Request, response: Response, next: NextFunction) => {
+        if (isEmpty(roles)) {
+            return
+        }
+
+        try {
+            const userContext = httpContext.get("user")
+            if (typeof userContext !== 'undefined') {
+                if (isNotEmpty(userContext.roles)) {
+                    const isAllowed = userContext.roles.some((role: string) => roles.includes(role));
+                    if (isAllowed) {
+                        return
+                    }
+                }
+            }
+        } catch (error: any) {
+            throw new HttpError(UNAUTHORIZED, getMessage("message.accessNotAllowed"))
+        }
+        throw new HttpError(UNAUTHORIZED, getMessage("message.accessNotAllowed"))
+    }
+}
+
+export default new MiddlewareCheckRolesFlow

package/src/flow/dispatcher/HttpDownloadDispatchHandlingFlow.ts

@@ -0,0 +1,21 @@
+import HttpDownloadDispatchSuccessFlow from "./HttpDownloadDispatchSuccessFlow";
+import HttpJsonDispatchErrorFlow from "./HttpJSONDispatchErrorFlow";
+
+const HttpDownloadDispatchHandlingFlow = (target: any, methodName: string, descriptor: PropertyDescriptor) => {
+  const originalMethod = descriptor.value;
+
+  descriptor.value = async (...args: any[]) => {
+    let [request, response, next] = args
+    try {
+      let [status, data] = await originalMethod.apply(this, args);
+      return HttpDownloadDispatchSuccessFlow.dispactch(response, status, data);
+    } catch (error: any) {
+      console.error(error)
+      HttpJsonDispatchErrorFlow.dispatch(response, error)
+    }
+  };
+
+  return descriptor;
+}
+
+export default HttpDownloadDispatchHandlingFlow

package/src/flow/dispatcher/HttpDownloadDispatchSuccessFlow.ts

@@ -0,0 +1,9 @@
+import { Response } from "express";
+
+class HttpDownloadDispatchSuccessFlow {
+  dispactch(response: Response, status: number, file?: any) {
+    response.status(status).send(file)
+  }
+}
+
+export default new HttpDownloadDispatchSuccessFlow

package/src/flow/dispatcher/HttpJsonDispatchErrorFlow.ts

@@ -0,0 +1,11 @@
+import { Response } from "express";
+import { INTERNAL_SERVER_ERROR } from "http-status";
+import HttpError from "../../model/HttpError";
+
+class HttpJsonDispatchErrorFlow {
+  dispatch(response: Response, error: HttpError) {
+    response.status(error.status || INTERNAL_SERVER_ERROR).json({ message: error.message, detail: error.detail })
+  }
+}
+
+export default new HttpJsonDispatchErrorFlow

package/src/flow/dispatcher/HttpJsonDispatchHandlingFlow.ts

@@ -0,0 +1,20 @@
+import HttpJsonDispatchErrorFlow from "./HttpJsonDispatchErrorFlow";
+import HttpJsonDispatchSuccessFlow from "./HttpJsonDispatchSuccessFlow";
+
+const HttpJsonDispatchHandlingFlow = (target: any, methodName: string, descriptor: PropertyDescriptor) => {
+  const originalMethod = descriptor.value;
+
+  descriptor.value = async (...args: any[]) => {
+    let [request, response, next] = args
+    try {
+      let [status, data] = await originalMethod.apply(this, args);
+      return HttpJsonDispatchSuccessFlow.dispactch(response, status, data);
+    } catch (error: any) {
+      HttpJsonDispatchErrorFlow.dispatch(response, error)
+    }
+  };
+
+  return descriptor;
+}
+
+export default HttpJsonDispatchHandlingFlow

package/src/flow/dispatcher/HttpJsonDispatchSuccessFlow.ts

@@ -0,0 +1,9 @@
+import { Response } from "express";
+
+class HttpJsonDispatchSuccessFlow {
+  dispactch(response: Response, status: number, payload?: any) {
+    response.status(status).json(payload)
+  }
+}
+
+export default new HttpJsonDispatchSuccessFlow

package/src/index.ts

@@ -0,0 +1,12 @@
+import { TControllerOptions } from "./model/TControllerOptions";
+import { TI18n } from "./model/TI18n";
+
+const initialize = (i18n: TI18n) => {
+  (global as any).i18nMessages = i18n
+}
+
+export {
+  initialize,
+  TControllerOptions
+}
+

package/src/model/HttpError.ts

@@ -0,0 +1,12 @@
+class HttpError extends Error {
+  status: number
+  detail: any
+  constructor(status: number, message: string, detail: any = undefined) {
+    super(message);
+    this.status = status
+    this.detail = detail
+    Object.setPrototypeOf(this, HttpError.prototype);
+  }
+}
+
+export default HttpError

package/src/model/TControllerOptions.ts

@@ -0,0 +1,7 @@
+export type TControllerOptions = {
+  uri: string,
+  basePath: string,
+  relativePath: string,
+  prefixRole: string
+  baseRoles: string[]
+}

package/src/model/TI18n.ts

@@ -0,0 +1,3 @@
+export type TI18n = {
+  [key: string]: {}
+}

package/src/utils/Utils.ts

@@ -0,0 +1,34 @@
+
+export const isNotEmpty = (obj: any) => {
+  return !isEmpty(obj)
+}
+
+export const isEmpty = (obj: any) => {
+  if (typeof obj === 'undefined') {
+    return true
+  }
+
+  if (typeof obj === 'number') {
+    if (isNaN(obj)) {
+      return true
+    }
+    return false
+  }
+
+  if (!obj) {
+    return true
+  }
+
+  if (Array.isArray(obj)) {
+    if (obj.length == 0) {
+      return true
+    }
+  }
+
+  if (obj === "") {
+    return true
+  }
+
+  return false
+
+}

package/tsconfig.json

@@ -0,0 +1,46 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "declaration": true,
+    "declarationDir": "./dist",
+    "outDir": "./dist",
+    "target": "es2021",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "include": ["src/**/*"]
+}
+// Property 'replaceAll' does not exist on type 'string'. 
+// Do you need to change your target library? Try changing the 'lib' compiler option to 'es2021' or later.ts(2550)
+
+
+// {
+//   "compilerOptions": {
+//     "esModuleInterop": true,
+//     "experimentalDecorators": true,
+//     // "target": "es6",
+//     "target": "es2016", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+//     "module": "commonjs",
+//     "outDir": "dist",
+//     "typeRoots": [
+//       "../node_modules/@types"
+//     ],
+//     "types": [
+//       "node"
+//     ],
+//     "lib": [
+//       "ES2021.String"
+//     ]
+//   },
+//   "include": [
+//     "**/*.ts",
+//     "*.ts",
+//     "config/Configs.ts",
+//   ],
+//   "exclude": [
+//     "node_modules"
+//   ],
+//   "buildOnSave": true,
+//   "compileOnSave": true
+// }