@duvdu-v1/duvdu 1.1.86 → 1.1.88

package/build/errors/bad-request-error.d.ts

@@ -1,9 +1,17 @@
 import { CustomError } from './custom-error';
+type LocalizedMessages = {
+    en: string;
+    ar: string;
+};
 export declare class BadRequestError extends CustomError {
     statusCode: number;
-    constructor(message: string);
+    private lang;
+    private messages;
+    private static defaultMessages;
+    constructor(message?: LocalizedMessages | string, lang?: string);
     serializeError(): {
         message: string;
         field?: string | undefined;
     }[];
 }
+export {};

package/build/errors/bad-request-error.js

@@ -1,15 +1,47 @@
 "use strict";
+// import { CustomError } from './custom-error';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BadRequestError = void 0;
+// export class BadRequestError extends CustomError {
+//   statusCode: number = 400;
+//   constructor(message: string) {
+//     super(message || 'bad-request error');
+//     Object.setPrototypeOf(this, BadRequestError.prototype);
+//   }
+//   serializeError(): { message: string; field?: string | undefined }[] {
+//     return [{ message: this.message || 'bad-request error' }];
+//   }
+// }
 const custom_error_1 = require("./custom-error");
 class BadRequestError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'bad-request error');
+    constructor(message, lang = 'en') {
+        let localizedMessage;
+        let messages;
+        if (!message) {
+            messages = BadRequestError.defaultMessages;
+            localizedMessage = messages[lang] || messages['en'];
+        }
+        else if (typeof message === 'string') {
+            messages = { en: message, ar: message };
+            localizedMessage = message;
+        }
+        else {
+            messages = message;
+            localizedMessage = message[lang] || message['en'];
+        }
+        super(localizedMessage);
         this.statusCode = 400;
+        this.messages = messages;
+        this.lang = lang;
         Object.setPrototypeOf(this, BadRequestError.prototype);
     }
     serializeError() {
-        return [{ message: this.message || 'bad-request error' }];
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
     }
 }
 exports.BadRequestError = BadRequestError;
+BadRequestError.defaultMessages = {
+    en: 'bad-request error',
+    ar: 'خطأ في الطلب',
+};

package/build/errors/data-base-connections.d.ts

@@ -1,8 +1,16 @@
 import { CustomError } from './custom-error';
+type LocalizedMessages = {
+    en: string;
+    ar: string;
+};
 export declare class DatabaseConnectionError extends CustomError {
     statusCode: number;
-    constructor(message?: string);
+    private lang;
+    private messages;
+    private static defaultMessages;
+    constructor(message?: LocalizedMessages | string, lang?: string);
     serializeError(): {
         message: string;
     }[];
 }
+export {};

package/build/errors/data-base-connections.js

@@ -1,19 +1,51 @@
 "use strict";
+// import { CustomError } from './custom-error';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseConnectionError = void 0;
+// export class DatabaseConnectionError extends CustomError {
+//   statusCode = 500;
+//   constructor(message?: string) {
+//     super(message || 'Error connecting to database');
+//     Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
+//   }
+//   serializeError() {
+//     return [
+//       {
+//         message: this.message || 'Error connecting to database',
+//       },
+//     ];
+//   }
+// }
 const custom_error_1 = require("./custom-error");
 class DatabaseConnectionError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'Error connecting to database');
+    constructor(message, lang = 'en') {
+        let localizedMessage;
+        let messages;
+        if (!message) {
+            messages = DatabaseConnectionError.defaultMessages;
+            localizedMessage = messages[lang] || messages['en'];
+        }
+        else if (typeof message === 'string') {
+            messages = { en: message, ar: message };
+            localizedMessage = message;
+        }
+        else {
+            messages = message;
+            localizedMessage = message[lang] || message['en'];
+        }
+        super(localizedMessage);
         this.statusCode = 500;
+        this.messages = messages;
+        this.lang = lang;
         Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
     }
     serializeError() {
-        return [
-            {
-                message: this.message || 'Error connecting to database',
-            },
-        ];
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
     }
 }
 exports.DatabaseConnectionError = DatabaseConnectionError;
+DatabaseConnectionError.defaultMessages = {
+    en: 'Error connecting to database',
+    ar: 'خطأ في الاتصال بقاعدة البيانات',
+};

package/build/errors/not-allowed-error.d.ts

@@ -1,9 +1,17 @@
 import { CustomError } from './custom-error';
+type LocalizedMessages = {
+    en: string;
+    ar: string;
+};
 export declare class NotAllowedError extends CustomError {
     statusCode: number;
-    constructor(message?: string);
+    private lang;
+    private messages;
+    private static defaultMessages;
+    constructor(message?: LocalizedMessages | string, lang?: string);
     serializeError(): {
         message: string;
         field?: string | undefined;
     }[];
 }
+export {};

package/build/errors/not-allowed-error.js

@@ -1,15 +1,47 @@
 "use strict";
+// import { CustomError } from './custom-error';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotAllowedError = void 0;
+// export class NotAllowedError extends CustomError {
+//   statusCode: number = 405;
+//   constructor(message?: string) {
+//     super(message || 'not allowed error');
+//     Object.setPrototypeOf(this, NotAllowedError.prototype);
+//   }
+//   serializeError(): { message: string; field?: string | undefined }[] {
+//     return [{ message: this.message || 'not allowed error' }];
+//   }
+// }
 const custom_error_1 = require("./custom-error");
 class NotAllowedError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'not allowed error');
+    constructor(message, lang = 'en') {
+        let localizedMessage;
+        let messages;
+        if (!message) {
+            messages = NotAllowedError.defaultMessages;
+            localizedMessage = messages[lang] || messages['en'];
+        }
+        else if (typeof message === 'string') {
+            messages = { en: message, ar: message };
+            localizedMessage = message;
+        }
+        else {
+            messages = message;
+            localizedMessage = message[lang] || message['en'];
+        }
+        super(localizedMessage);
         this.statusCode = 405;
+        this.messages = messages;
+        this.lang = lang;
         Object.setPrototypeOf(this, NotAllowedError.prototype);
     }
     serializeError() {
-        return [{ message: this.message || 'not allowed error' }];
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
     }
 }
 exports.NotAllowedError = NotAllowedError;
+NotAllowedError.defaultMessages = {
+    en: 'Not allowed error',
+    ar: 'خطأ: غير مسموح',
+};

package/build/errors/notfound-error.d.ts

@@ -1,9 +1,17 @@
 import { CustomError } from './custom-error';
+type LocalizedMessages = {
+    en: string;
+    ar: string;
+};
 export declare class NotFound extends CustomError {
     statusCode: number;
-    constructor(message?: string);
+    private lang;
+    private messages;
+    private static defaultMessages;
+    constructor(message?: LocalizedMessages | string, lang?: string);
     serializeError(): {
         message: string;
         field?: string | undefined;
     }[];
 }
+export {};

package/build/errors/notfound-error.js

@@ -1,15 +1,47 @@
 "use strict";
+// import { CustomError } from './custom-error';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotFound = void 0;
+// export class NotFound extends CustomError {
+//   statusCode = 404;
+//   constructor(message?: string) {
+//     super(message || 'not found error');
+//     Object.setPrototypeOf(this, NotFound.prototype);
+//   }
+//   serializeError(): { message: string; field?: string | undefined }[] {
+//     return [{ message: this.message || 'not found error' }];
+//   }
+// }
 const custom_error_1 = require("./custom-error");
 class NotFound extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'not found error');
+    constructor(message, lang = 'en') {
+        let localizedMessage;
+        let messages;
+        if (!message) {
+            messages = NotFound.defaultMessages;
+            localizedMessage = messages[lang] || messages['en'];
+        }
+        else if (typeof message === 'string') {
+            messages = { en: message, ar: message };
+            localizedMessage = message;
+        }
+        else {
+            messages = message;
+            localizedMessage = message[lang] || message['en'];
+        }
+        super(localizedMessage);
         this.statusCode = 404;
+        this.messages = messages;
+        this.lang = lang;
         Object.setPrototypeOf(this, NotFound.prototype);
     }
     serializeError() {
-        return [{ message: this.message || 'not found error' }];
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
     }
 }
 exports.NotFound = NotFound;
+NotFound.defaultMessages = {
+    en: 'Not found error',
+    ar: 'خطأ: لم يتم العثور على الصفحة',
+};

package/build/errors/unauthenticated-error.d.ts

@@ -1,9 +1,17 @@
 import { CustomError } from './custom-error';
+type LocalizedMessages = {
+    en: string;
+    ar: string;
+};
 export declare class UnauthenticatedError extends CustomError {
     statusCode: number;
-    constructor(message?: string);
+    private lang;
+    private messages;
+    private static defaultMessages;
+    constructor(message?: LocalizedMessages | string, lang?: string);
     serializeError(): {
         message: string;
         field?: string | undefined;
     }[];
 }
+export {};

package/build/errors/unauthenticated-error.js

@@ -1,15 +1,47 @@
 "use strict";
+// import { CustomError } from './custom-error';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnauthenticatedError = void 0;
+// export class UnauthenticatedError extends CustomError {
+//   statusCode = 401;
+//   constructor(message?: string) {
+//     super(message || 'un-authenticated error');
+//     Object.setPrototypeOf(this, UnauthenticatedError.prototype);
+//   }
+//   serializeError(): { message: string; field?: string | undefined }[] {
+//     return [{ message: this.message || 'un-authenticated error' }];
+//   }
+// }
 const custom_error_1 = require("./custom-error");
 class UnauthenticatedError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'un-authenticated error');
+    constructor(message, lang = 'en') {
+        let localizedMessage;
+        let messages;
+        if (!message) {
+            messages = UnauthenticatedError.defaultMessages;
+            localizedMessage = messages[lang] || messages['en'];
+        }
+        else if (typeof message === 'string') {
+            messages = { en: message, ar: message };
+            localizedMessage = message;
+        }
+        else {
+            messages = message;
+            localizedMessage = message[lang] || message['en'];
+        }
+        super(localizedMessage);
         this.statusCode = 401;
+        this.messages = messages;
+        this.lang = lang;
         Object.setPrototypeOf(this, UnauthenticatedError.prototype);
     }
     serializeError() {
-        return [{ message: this.message || 'un-authenticated error' }];
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
     }
 }
 exports.UnauthenticatedError = UnauthenticatedError;
+UnauthenticatedError.defaultMessages = {
+    en: 'Unauthenticated error',
+    ar: 'خطأ: غير مصدق',
+};

package/build/errors/unauthorized-error.d.ts

@@ -1,9 +1,17 @@
 import { CustomError } from './custom-error';
+type LocalizedMessages = {
+    en: string;
+    ar: string;
+};
 export declare class UnauthorizedError extends CustomError {
     statusCode: number;
-    constructor(message?: string);
+    private lang;
+    private messages;
+    private static defaultMessages;
+    constructor(message?: LocalizedMessages | string, lang?: string);
     serializeError(): {
         message: string;
         field?: string | undefined;
     }[];
 }
+export {};

package/build/errors/unauthorized-error.js

@@ -1,15 +1,47 @@
 "use strict";
+// import { CustomError } from './custom-error';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnauthorizedError = void 0;
+// export class UnauthorizedError extends CustomError {
+//   statusCode = 403;
+//   constructor(message?: string) {
+//     super(message || 'un-unauthorized error');
+//     Object.setPrototypeOf(this, UnauthorizedError.prototype);
+//   }
+//   serializeError(): { message: string; field?: string | undefined }[] {
+//     return [{ message: this.message || 'un-unauthorized error' }];
+//   }
+// }
 const custom_error_1 = require("./custom-error");
 class UnauthorizedError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'un-unauthorized error');
+    constructor(message, lang = 'en') {
+        let localizedMessage;
+        let messages;
+        if (!message) {
+            messages = UnauthorizedError.defaultMessages;
+            localizedMessage = messages[lang] || messages['en'];
+        }
+        else if (typeof message === 'string') {
+            messages = { en: message, ar: message };
+            localizedMessage = message;
+        }
+        else {
+            messages = message;
+            localizedMessage = message[lang] || message['en'];
+        }
+        super(localizedMessage);
         this.statusCode = 403;
+        this.messages = messages;
+        this.lang = lang;
         Object.setPrototypeOf(this, UnauthorizedError.prototype);
     }
     serializeError() {
-        return [{ message: this.message || 'un-unauthorized error' }];
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
     }
 }
 exports.UnauthorizedError = UnauthorizedError;
+UnauthorizedError.defaultMessages = {
+    en: 'Unauthorized error',
+    ar: 'خطأ: غير مسموح',
+};

package/build/middlewares/auth.middleware.js

@@ -15,13 +15,16 @@ const unauthenticated_error_1 = require("../errors/unauthenticated-error");
 const unauthorized_error_1 = require("../errors/unauthorized-error");
 const isauthenticated = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     if (!req.session.access)
-        return next(new unauthenticated_error_1.UnauthenticatedError('access token not found'));
+        return next(new unauthenticated_error_1.UnauthenticatedError({ en: 'access token not found', ar: 'الرمز المميز للوصول غير موجود' }, req.lang));
     let payload;
     try {
         payload = (0, jsonwebtoken_1.verify)(req.session.access, process.env.JWT_KEY);
         req.loggedUser = payload;
         if (req.loggedUser.isBlocked.value)
-            return next(new unauthorized_error_1.UnauthorizedError(`user is blocked:${req.loggedUser.isBlocked.reason}`));
+            return next(new unauthorized_error_1.UnauthorizedError({
+                en: `Forbidden: User is blocked ${req.loggedUser.isBlocked.reason}`,
+                ar: ` ممنوع: المستخدم محظور ${req.loggedUser.isBlocked.reason}`,
+            }, req.lang));
     }
     catch (error) {
         return res.status(423).json({ message: 'access token expired' });

package/package.json

@@ -1,55 +1,55 @@
-{
-  "name": "@duvdu-v1/duvdu",
-  "version": "1.1.86",
-  "main": "./build/index.js",
-  "types": "./build/index.d.ts",
-  "files": [
-    "build/**/*"
-  ],
-  "scripts": {
-    "clean": "rimraf ./build",
-    "build": "npm run clean && tsc",
-    "fix:build": "mv ./build/common/src/* ./build && rm -rf ./build/auth ./build/common",
-    "pub": "git add . && git commit -m \"updates\" && npm version patch && npm run build && npm publish",
-    "lint": "eslint .",
-    "lint:fix": "eslint --fix .",
-    "format": "prettier --write ."
-  },
-  "keywords": [],
-  "author": "motemed khaled",
-  "license": "ISC",
-  "dependencies": {
-    "@duvdu-v1/duvdu": "^1.1.4",
-    "@types/express": "^4.17.21",
-    "@types/express-session": "^1.18.0",
-    "@types/jsonwebtoken": "^9.0.5",
-    "@types/multer": "^1.4.11",
-    "@types/node": "^20.11.0",
-    "@typescript-eslint/eslint-plugin": "^6.19.0",
-    "@typescript-eslint/parser": "^6.19.0",
-    "aws-sdk": "^2.1595.0",
-    "connect-redis": "^7.1.1",
-    "express": "^4.18.2",
-    "express-async-errors": "^3.1.1",
-    "express-session": "^1.18.0",
-    "express-validator": "^7.0.1",
-    "jsonwebtoken": "^9.0.2",
-    "mongoose": "^8.0.4",
-    "multer": "^1.4.5-lts.1",
-    "node-nats-streaming": "^0.3.2",
-    "redis": "^4.6.13",
-    "rimraf": "^5.0.5",
-    "typescript": "^5.3.3",
-    "uuid": "^9.0.1"
-  },
-  "devDependencies": {
-    "@types/uuid": "^9.0.8",
-    "del-cli": "^5.1.0",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-prettier": "^5.1.3",
-    "prettier": "^3.2.4"
-  },
-  "description": ""
-}
+{
+  "name": "@duvdu-v1/duvdu",
+  "version": "1.1.88",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "files": [
+    "build/**/*"
+  ],
+  "scripts": {
+    "clean": "rimraf ./build",
+    "build": "npm run clean && tsc",
+    "fix:build": "mv ./build/common/src/* ./build && rm -rf ./build/auth ./build/common",
+    "pub": "git add . && git commit -m \"updates\" && npm version patch && npm run build && npm publish",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "format": "prettier --write ."
+  },
+  "keywords": [],
+  "author": "motemed khaled",
+  "license": "ISC",
+  "dependencies": {
+    "@duvdu-v1/duvdu": "^1.1.4",
+    "@types/express": "^4.17.21",
+    "@types/express-session": "^1.18.0",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/multer": "^1.4.11",
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^6.19.0",
+    "@typescript-eslint/parser": "^6.19.0",
+    "aws-sdk": "^2.1595.0",
+    "connect-redis": "^7.1.1",
+    "express": "^4.18.2",
+    "express-async-errors": "^3.1.1",
+    "express-session": "^1.18.0",
+    "express-validator": "^7.0.1",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.0.4",
+    "multer": "^1.4.5-lts.1",
+    "node-nats-streaming": "^0.3.2",
+    "redis": "^4.6.13",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/uuid": "^9.0.8",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.4"
+  },
+  "description": ""
+}