biz-slide-core 1.1.0 → 1.1.2

package/utilities/callWithRetries.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callWithRetries = void 0;
+function callWithRetries(retryCount, failedMessage, functionRef) {
+    var args = [];
+    for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+    }
+    return __awaiter(this, void 0, void 0, function () {
+        var error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, functionRef.apply(void 0, args)];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2:
+                    error_1 = _a.sent();
+                    if (retryCount <= 0)
+                        throw error_1;
+                    console.log(failedMessage);
+                    return [2 /*return*/, callWithRetries.apply(void 0, __spreadArray([retryCount - 1, failedMessage, functionRef], args, false))];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.callWithRetries = callWithRetries;

package/utilities/createFolder.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFolder = void 0;
+var fs_1 = __importDefault(require("fs"));
+function createFolder(folderPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            try {
+                if (!fs_1.default.existsSync(folderPath)) {
+                    fs_1.default.mkdirSync(folderPath);
+                }
+                console.log("Folder \"".concat(folderPath, "\" is ready."));
+            }
+            catch (error) {
+                console.error("Error: ".concat(error.message));
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+exports.createFolder = createFolder;

package/utilities/encryptionUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyUid = exports.signUid = void 0;
+var jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+var signUid = function (value) {
+    return jsonwebtoken_1.default.sign({ value: value }, process.env.JWTSECRET || 'secret', {
+        expiresIn: '8h' // expires in 8 hours
+    });
+};
+exports.signUid = signUid;
+var verifyUid = function (token) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, new Promise(function (resolve) {
+                var jwtToken = token.split(" ")[1];
+                jsonwebtoken_1.default.verify(jwtToken, process.env.JWTSECRET || 'secret', function (err, decoded) {
+                    if (err) {
+                        console.log(err);
+                        resolve(null);
+                    }
+                    else {
+                        resolve(decoded);
+                    }
+                });
+            })];
+    });
+}); };
+exports.verifyUid = verifyUid;

package/utilities/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./callWithRetries"), exports);
+__exportStar(require("./createFolder"), exports);
+__exportStar(require("./encryptionUtils"), exports);

package/entity/image.entity.ts

@@ -1,32 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface IImageSchema {
-  focusPoint: { x: number, y: number };
-  url: string;
-  radius: string;
-  keywords: [string] | null;
-  title: string;
-  userId: Types.ObjectId;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date;
-}
-
-const ImageSchema = new Schema<IImageSchema>(
-  {
-    focusPoint: { x: Number, y: Number },
-    url: { type: String, required: true },
-    radius: { type: String, required: true },
-    keywords: { type: [String], default: [] },
-    title: { type: String, required: true },
-    userId: { type: Schema.Types.ObjectId, ref: "user" },
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const ImageModel = model<IImageSchema>("image", ImageSchema);

package/entity/index.ts

@@ -1,10 +0,0 @@
-export * from "./image.entity";
-export * from "./png-svg.entity";
-export * from "./ppt-event.entity";
-export * from "./ppt-slide.entity";
-export * from "./ppt.entity";
-export * from "./slide-layout.entity";
-export * from "./slide.entity";
-export * from "./socket.entity";
-export * from "./template.entity";
-export * from "./user.entity";

package/entity/ppt-event.entity.ts

@@ -1,23 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-
-export interface IPPTEventSchema {
-    pptRef: Types.ObjectId;
-    message: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-}
-
-const PPTEventSchema = new Schema<IPPTEventSchema>(
-    {
-      createdAt: { type: Date, default: Date.now() },
-      updatedAt: { type: Date, default: Date.now() },
-      pptRef: { type: Schema.Types.ObjectId, ref: 'ppt' },
-      message: { type: String, default: null }
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const PPTSlideEventModel = model<IPPTEventSchema>("ppt-event", PPTEventSchema);

package/entity/ppt-slide.entity.ts

@@ -1,31 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-export interface IPPTSlideSchema {
-    pptRef: Types.ObjectId;
-    slideRef: Types.ObjectId;
-    slideLayoutRef: Types.ObjectId;
-    title: string;
-    rawData: string;
-    images: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-    deletedAt?: Date;
-}
-
-const PPTSlideSchema = new Schema<IPPTSlideSchema>(
-    {
-      createdAt: { type: Date, default: Date.now() },
-      updatedAt: { type: Date, default: Date.now() },
-      deletedAt: { type: Date, default: null },
-      pptRef: { type: Schema.Types.ObjectId, ref: 'ppt' },
-      slideRef: { type: Schema.Types.ObjectId, ref: 'slide' },
-      slideLayoutRef: { type: Schema.Types.ObjectId, ref: 'slide-layout' },
-      title: { type: String, default: null },
-      rawData: { type: String, default: "{}" },
-      images: { type: String, default: "{}" },
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const PPTSlideModel = model<IPPTSlideSchema>("ppt-slide", PPTSlideSchema);

package/entity/ppt.entity.ts

@@ -1,60 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-interface IPPTQuestions {
-  question: string;
-  answer: string;
-}
-
-const questionSchema = new Schema<IPPTQuestions>({
-  question: { type: String},
-  answer : { type : String }
-}, {
-  timestamps: false,
-  _id: false
-})
-
-export interface IPPTQuestionSchema {
-  question: string;
-  answer: string;
-}
-
-export interface IPPTSchema {
-    systemGeneratedtopics: Array<string>;
-    colors: Array<string>;
-    slideRefs: Types.ObjectId[];
-    templateRef: Types.ObjectId;
-    template_type: string;
-    prompt: string;
-    userId: string;
-    questions: IPPTQuestions[];
-    isLocked?: boolean;
-    fileCreated?: boolean;
-    isCompleted?: boolean;
-    createdAt?: Date;
-    updatedAt?: Date;
-    deletedAt?: Date;
-}
-
-const PPTSchema = new Schema<IPPTSchema>(
-    {
-      createdAt: { type: Date, default: Date.now() },
-      updatedAt: { type: Date, default: Date.now() },
-      deletedAt: { type: Date, default: null },
-      isLocked: { type: Boolean, default: false },
-      isCompleted: { type: Boolean, default: false },
-      fileCreated: { type: Boolean, default: false },
-      userId: { type: String, default: null },
-      template_type: { type: String, default: null },
-      systemGeneratedtopics: { type: [String], default: [], _id: false },
-      questions: [questionSchema],
-      colors: { type: [String], default: [], _id: false },
-      prompt: { type: String, default: null },
-      templateRef: { type: Schema.Types.ObjectId, ref: 'template' },
-      slideRefs: {type: [{ type: Schema.Types.ObjectId, ref: 'ppt-slide' }], default: [], _id: false}
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const PPTModel = model<IPPTSchema>("ppt", PPTSchema);

package/entity/slide-layout.entity.ts

@@ -1,24 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface ISlideLayoutSchema {
-  name: string;
-  templateId: Types.ObjectId;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date;
-}
-
-const SlideLayoutSchema = new Schema<ISlideLayoutSchema>(
-  {
-    name: { type: String, default: "", required: true },
-    templateId: { type: Schema.Types.ObjectId, ref: "template" },
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const SlideLayoutModel = model<ISlideLayoutSchema>("slide-layout", SlideLayoutSchema);

package/entity/slide.entity.ts

@@ -1,47 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-interface layer {
-  metaType: String;
-  optionsMeta: String;
-  chatMeta: string;
-}
-
-const layerSchema = new Schema<layer>({
-  metaType: { type: String, enum: ['text', 'image', 'shape', 'list', 'table'] },
-  optionsMeta: { type: String },
-  chatMeta: { type: String },
-}, {
-  timestamps: false,
-  _id: false
-})
-
-export interface ISlideSchema {
-  name: string;
-  postfix: string;
-  rules: string;
-  slideLayoutId: Types.ObjectId;
-  templateId: Types.ObjectId;
-  layers: layer[];
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date;
-}
-
-const SlideSchema = new Schema<ISlideSchema>(
-  {
-    name: { type: String, default: "", required: true },
-    postfix: { type: String, default: "" },
-    rules: { type: String, default: "" },
-    layers: [layerSchema],
-    slideLayoutId: { type: Schema.Types.ObjectId, ref: "slide-layout" },
-    templateId: { type: Schema.Types.ObjectId, ref: "template" },
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const SlideModel = model<ISlideSchema>("slide", SlideSchema);

package/entity/socket.entity.ts

@@ -1,22 +0,0 @@
-import { Schema, model, Types } from "mongoose";
-
-export interface ISocketSchema {
-  userId: string;
-  socketIds: Array<string>;
-  createdAt?: Date;
-  updatedAt?: Date;
-}
-
-const SocketSchema = new Schema<ISocketSchema>(
-    {
-      createdAt: { type: Date, default: Date.now() },
-      updatedAt: { type: Date, default: Date.now() },
-      userId: { type: String, default: null },
-      socketIds: { type: [String], default: [] }
-    },
-    {
-        timestamps: true,
-    }
-);
-
-export const SocketModel = model<ISocketSchema>("socket", SocketSchema);

package/entity/template.entity.ts

@@ -1,24 +0,0 @@
-import { Schema, model } from "mongoose";
-
-export interface ITemplateSchema{
-  name: string;
-  template_type: string;
-  createdAt: Date,
-  updatedAt: Date,
-  deletedAt: Date
-}
-
-const TemplateSchema = new Schema<ITemplateSchema>(
-  {
-    name: { type: String, default: "", required: true },
-    template_type: { type: String, default: "", required: true },
-    createdAt: { type: Date, default: Date.now() },
-    updatedAt: { type: Date, default: Date.now() },
-    deletedAt: { type: Date, default: null },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const TemplateModel = model<ITemplateSchema>("template", TemplateSchema);

package/entity/user.entity.ts

@@ -1,26 +0,0 @@
-import { Schema, model } from "mongoose";
-
-interface IUser {
-  email: string | null;
-  password: string,
-  role: string,
-  createdAt: Date,
-  updatedAt: Date,
-  deletedAt: Date
-}
-
-const UserSchema = new Schema<IUser>(
-  {
-    email: { type: String, unique: true, sparse: true },
-    password: { type: String, default: null },
-    role: { type: String, default: null },
-    createdAt: { type: Date, default: Date.now()},
-    updatedAt: { type: Date, default: Date.now()},
-    deletedAt: { type: Date, default: null},
-  },
-  {
-    timestamps: true,
-  }
-);
-
-export const UserModel = model<IUser>("user", UserSchema);

package/middleware/authentication.ts

@@ -1,64 +0,0 @@
-import { Response, NextFunction } from "express";
-import { verifyUid } from "../utilities";
-import { IRequest } from "../types";
-import { UserModel } from "../entity";
-
-
-const authorize = (roles: string[]) => {
-  return async function (req: IRequest, res: Response, next: NextFunction) {
-    if (!req.headers.authorization) {
-      return res.status(401).json({ message: 'Unauthorized' })
-    }
-    if (!roles.length) {
-      return res.status(401).json({ message: 'Unauthorized' })
-    }
-    if (req.headers.authorization) {
-      const token = await verifyUid(req.headers.authorization);
-      if (!token) {
-        return res.status(401).json({ message: 'Session Expired' })
-      }
-
-      let user = await UserModel.findOne({ email: token.value.email })
-
-      if (!user) {
-        return res.status(401).json({ message: 'No User Found' })
-      }
-
-      const hasAccess = roles.find(role => role === user.role);
-
-      if (!hasAccess) {
-        return res.status(403).json({ message: 'Forbbiden' })
-      }
-
-      const { createdAt, updatedAt, deletedAt, password,  ...rest } = user.toObject();
-
-      req.user = rest;
-      next();
-    }
-  }
-}
-
-const authorizeWithSlideApp = () => {
-  return async function (req: IRequest, res: Response, next: NextFunction) {
-    if (!req.headers.authorization) {
-      return res.status(401).json({ message: 'Unauthorized' })
-    }
-    
-    if (req.headers.authorization) {
-      const token = await verifyUid(req.headers.authorization);
-      if (!token) {
-        return res.status(401).json({ message: 'Session Expired' })
-      }
-
-      // token.value.customerid
-
-      req.user = {
-        userId: "123" //token.value.customerid
-      }
-
-      next();
-    }
-  }
-}
-
-export {authorize, authorizeWithSlideApp};

package/middleware/index.ts

@@ -1,3 +0,0 @@
-export * from "./authentication";
-export * from "./role";
-export * from "./schemaValidate";

package/middleware/role.ts

@@ -1,5 +0,0 @@
-export const ROLES = {
-  User: 'User',
-  Admin: 'Admin',
-  SuperAdmin: 'SuperAdmin'
-}

package/middleware/schemaValidate.ts

@@ -1,20 +0,0 @@
-import { NextFunction, Response } from "express";
-import Joi from 'joi';
-
-import { IRequest } from "../types";
-
-export const validateSchema = (schema: Joi.ObjectSchema<any>) => {
-  return async function (req: IRequest, res: Response, next: NextFunction) {
-
-    const { error } = schema.validate(req.body, { abortEarly: false });
-
-    if(error) {
-      const errorMessage = error.details.map((err) => err.message).join(', ');
-      return res.status(400).json({ message: errorMessage });
-    } else {
-      next();
-    }
-  }
-}
-
-

package/resHandler/errorHandler.ts

@@ -1,44 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-
-export class BadRequestError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'BadRequestError';
-  }
-}
-
-export class NotFoundRequestError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'NotFoundRequestError';
-  }
-}
-
-
-
-// Custom error handler middleware
-export const errorHandler = (
-  err: Error,
-  req: Request,
-  res: Response,
-  next: NextFunction
-) => {
-  console.error(err.stack); // Log the error for debugging
-
-  let statusCode = 500; // Default status code
-  let errorMessage = 'Internal Server Error'; // Default error message
-
-  if (err instanceof BadRequestError) {
-    statusCode = 400;
-    errorMessage = err.message;
-  } else if(err instanceof NotFoundRequestError) {
-    statusCode = 404;
-    errorMessage = err.message;
-  }
-
-  // Send an error response
-  res.status(statusCode).json({
-    message: errorMessage,
-    error: err.name // Optionally send the error name/type
-  });
-};