@duvdu-v1/duvdu 1.1.85 → 1.1.87

package/build/auth/src/nats-wrapper.d.ts

@@ -0,0 +1,8 @@
+import nats from 'node-nats-streaming';
+declare class NatsWrapper {
+    private _client?;
+    get client(): nats.Stan;
+    connect(clusterId: string, clientId: string, url: string): Promise<void>;
+}
+export declare const natsWrapper: NatsWrapper;
+export {};

package/build/auth/src/nats-wrapper.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.natsWrapper = void 0;
+const node_nats_streaming_1 = __importDefault(require("node-nats-streaming"));
+class NatsWrapper {
+    get client() {
+        if (!this._client) {
+            throw new Error('can not access nats client before conection');
+        }
+        return this._client;
+    }
+    connect(clusterId, clientId, url) {
+        this._client = node_nats_streaming_1.default.connect(clusterId, clientId, { url });
+        return new Promise((resolve, reject) => {
+            this.client.on('connect', () => {
+                console.log('connected to nats');
+                resolve();
+            });
+            this.client.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+}
+exports.natsWrapper = new NatsWrapper();

package/build/{errors → common/src/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/common/src/errors/bad-request-error.js

@@ -0,0 +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, 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() {
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
+    }
+}
+exports.BadRequestError = BadRequestError;
+BadRequestError.defaultMessages = {
+    en: 'bad-request error',
+    ar: 'خطأ في الطلب',
+};

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

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

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

@@ -0,0 +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, 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() {
+        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 → common/src/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/common/src/errors/not-allowed-error.js

@@ -0,0 +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, 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() {
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
+    }
+}
+exports.NotAllowedError = NotAllowedError;
+NotAllowedError.defaultMessages = {
+    en: 'Not allowed error',
+    ar: 'خطأ: غير مسموح',
+};

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

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

package/build/common/src/errors/notfound-error.js

@@ -0,0 +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, 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() {
+        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 → common/src/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/common/src/errors/unauthenticated-error.js

@@ -0,0 +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, 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() {
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
+    }
+}
+exports.UnauthenticatedError = UnauthenticatedError;
+UnauthenticatedError.defaultMessages = {
+    en: 'Unauthenticated error',
+    ar: 'خطأ: غير مصدق',
+};

package/build/{errors → common/src/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/common/src/errors/unauthorized-error.js

@@ -0,0 +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, 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() {
+        const localizedMessage = this.messages[this.lang] || this.messages['en'];
+        return [{ message: localizedMessage }];
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+UnauthorizedError.defaultMessages = {
+    en: 'Unauthorized error',
+    ar: 'خطأ: غير مسموح',
+};

package/build/{middlewares → common/src/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/build/{models → common/src/models}/User.model.js

@@ -42,6 +42,12 @@ const userSchema = new mongoose_1.Schema({
         followers: { type: Number, default: 0 },
         following: { type: Number, default: 0 },
     },
+    favourites: [
+        {
+            project: { type: mongoose_1.Schema.Types.ObjectId, refPath: 'favourites.cycle', required: true },
+            cycle: { type: String, required: true },
+        },
+    ],
 }, {
     timestamps: true,
     collection: model_names_1.MODELS.user,

package/build/{types → common/src/types}/User.d.ts

@@ -85,4 +85,8 @@ export interface Iuser {
     };
     notificationToken: string | null;
     isFollow?: boolean;
+    favourites: {
+        project: Types.ObjectId;
+        cycle: string;
+    }[];
 }

package/package.json

@@ -1,55 +1,55 @@
-{
-  "name": "@duvdu-v1/duvdu",
-  "version": "1.1.85",
-  "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.87",
+  "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": ""
+}

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

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BadRequestError = void 0;
-const custom_error_1 = require("./custom-error");
-class BadRequestError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'bad-request error');
-        this.statusCode = 400;
-        Object.setPrototypeOf(this, BadRequestError.prototype);
-    }
-    serializeError() {
-        return [{ message: this.message || 'bad-request error' }];
-    }
-}
-exports.BadRequestError = BadRequestError;

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

@@ -1,8 +0,0 @@
-import { CustomError } from './custom-error';
-export declare class DatabaseConnectionError extends CustomError {
-    statusCode: number;
-    constructor(message?: string);
-    serializeError(): {
-        message: string;
-    }[];
-}

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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseConnectionError = void 0;
-const custom_error_1 = require("./custom-error");
-class DatabaseConnectionError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'Error connecting to database');
-        this.statusCode = 500;
-        Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
-    }
-    serializeError() {
-        return [
-            {
-                message: this.message || 'Error connecting to database',
-            },
-        ];
-    }
-}
-exports.DatabaseConnectionError = DatabaseConnectionError;

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

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotAllowedError = void 0;
-const custom_error_1 = require("./custom-error");
-class NotAllowedError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message || 'not allowed error');
-        this.statusCode = 405;
-        Object.setPrototypeOf(this, NotAllowedError.prototype);
-    }
-    serializeError() {
-        return [{ message: this.message || 'not allowed error' }];
-    }
-}
-exports.NotAllowedError = NotAllowedError;