@duvdu-v1/duvdu 1.0.0

package/custom.d.ts

@@ -0,0 +1,7 @@
+import { Request } from "express";
+import { IjwtPayload } from "./src/types/JwtPayload";
+declare module "express-serve-static-core" {
+  export interface Request {
+    user?: IjwtPayload;
+  }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@duvdu-v1/duvdu",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@types/node": "^20.11.0",
+    "express": "^4.18.2",
+    "express-validator": "^7.0.1",
+    "mongoose": "^8.0.4",
+    "multer": "^1.4.5-lts.1",
+    "node-nats-streaming": "^0.3.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/multer": "^1.4.11"
+  }
+}

package/src/errors/bad-request-error.ts

@@ -0,0 +1,12 @@
+import { CustomError } from "./custom-error";
+
+export class BadRequestError extends CustomError {
+  statusCode: number = 400;
+  constructor(message: string) {
+    super(message);
+    Object.setPrototypeOf(this, BadRequestError.prototype);
+  }
+  serializeError(): { message: string; field?: string | undefined }[] {
+    return [{ message: this.message }];
+  }
+}

package/src/errors/custom-error.ts

@@ -0,0 +1,9 @@
+export abstract class CustomError extends Error {
+  abstract statusCode: number;
+  constructor(message: string) {
+    super(message);
+    Object.setPrototypeOf(this, CustomError.prototype);
+  }
+
+  abstract serializeError(): { message: string; field?: string }[];
+}

package/src/errors/notfound-error.ts

@@ -0,0 +1,12 @@
+import { CustomError } from "./custom-error";
+
+export class NotFound extends CustomError {
+  statusCode = 404;
+  constructor() {
+    super("not found error");
+    Object.setPrototypeOf(this, NotFound.prototype);
+  }
+  serializeError(): { message: string; field?: string | undefined }[] {
+    return [{ message: "not found error" }];
+  }
+}

package/src/errors/unauthenticated-error.ts

@@ -0,0 +1,13 @@
+import { CustomError } from "./custom-error";
+
+export class UnauthenticatedError extends CustomError {
+  statusCode = 401;
+  constructor() {
+    super("un-authenticated error");
+    Object.setPrototypeOf(this, UnauthenticatedError.prototype);
+  }
+
+  serializeError(): { message: string; field?: string | undefined }[] {
+    return [{ message: "un-authenticated error" }];
+  }
+}

package/src/errors/unauthorized-error.ts

@@ -0,0 +1,13 @@
+import { CustomError } from "./custom-error";
+
+export class UnauthorizedError extends CustomError {
+  statusCode = 403;
+  constructor() {
+    super("un-unauthorized error");
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
+  }
+
+  serializeError(): { message: string; field?: string | undefined }[] {
+    return [{ message: "un-unauthorized error" }];
+  }
+}

package/src/errors/validation-error.ts

@@ -0,0 +1,16 @@
+import { CustomError } from "./custom-error";
+import { ValidationError as vError } from "express-validator";
+
+export class ValidationError extends CustomError {
+  statusCode = 422;
+  constructor(public error: vError[]) {
+    super("validation error");
+    Object.setPrototypeOf(this, ValidationError.prototype);
+  }
+  serializeError(): { message: string; field?: string | undefined }[] {
+    return this.error.map((el) => {
+      if (el.type === "field") return { message: el.msg, field: el.path };
+      return { message: el.msg };
+    });
+  }
+}

package/src/events/base-listener.ts

@@ -0,0 +1,44 @@
+import { Stan, Message } from "node-nats-streaming";
+import { Subject } from "./subject";
+
+interface Event {
+  subject: Subject;
+  data: any;
+}
+
+export abstract class Lisener<T extends Event> {
+  abstract queueGroupName: string;
+  abstract subject: T["subject"];
+  abstract onMessage(data: T["data"], msg: Message): void;
+  protected client: Stan;
+  protected ackWait = 5 * 1000;
+  constructor(client: Stan) {
+    this.client = client;
+  }
+  subscriptionOptions() {
+    return this.client
+      .subscriptionOptions()
+      .setDeliverAllAvailable()
+      .setManualAckMode(true)
+      .setAckWait(this.ackWait)
+      .setDurableName(this.queueGroupName);
+  }
+
+  listen() {
+    const subscription = this.client.subscribe(
+      this.subject,
+      this.queueGroupName,
+      this.subscriptionOptions()
+    );
+    subscription.on("message", (msg: Message) => {
+      console.log(`Message received: ${this.subject} / ${this.queueGroupName}`);
+      const parsedData = this.parseMessage(msg);
+      this.onMessage(parsedData, msg);
+    });
+  }
+
+  parseMessage(msg: Message) {
+    const data = msg.getData();
+    return typeof data === "string" ? JSON.parse(data) : JSON.parse(data.toString("utf-8"));
+  }
+}

package/src/events/base-publisher.ts

@@ -0,0 +1,25 @@
+import { Stan } from "node-nats-streaming";
+import { Subject } from "./subject";
+
+interface Event {
+  subject: Subject;
+  data: any;
+}
+
+export abstract class Publisher<T extends Event> {
+  abstract subject: T["subject"];
+  protected client: Stan;
+
+  constructor(client: Stan) {
+    this.client = client;
+  }
+
+  publish(data: T["data"]): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.client.publish(this.subject, JSON.stringify(data), (err) => {
+        if (err) reject(err);
+        resolve();
+      });
+    });
+  }
+}

package/src/events/subject.ts

@@ -0,0 +1,3 @@
+export enum Subject {
+  orderCreated = "order:created",
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from "./events/base-listener";
+export * from "./events/base-publisher";
+export * from "./events/subject";
+export * from "./errors/bad-request-error";
+// export * from "./errors/custom-error";
+export * from "./errors/notfound-error";
+export * from "./errors/unauthenticated-error";
+export * from "./errors/unauthorized-error";
+export * from "./errors/validation-error";
+export * from "./middlewares/global-error-handling.middleware";
+// export * from "./types/Pagination";
+// export * from "./types/UrlQuery";
+export * from "./utils/api-feature";

package/src/middlewares/global-error-handling.middleware.ts

@@ -0,0 +1,25 @@
+import { ErrorRequestHandler } from "express";
+import { CustomError } from "../errors/custom-error";
+import { MulterError } from "multer";
+export const globalErrorHandlingMiddleware: ErrorRequestHandler = (err, req, res, next) => {
+  // custom error
+  if (err instanceof CustomError) {
+    return res.status(err.statusCode).json({ errors: err.serializeError() });
+  }
+  // mongo dublicate error
+  if (err.name === "MongoServerError" && err.code == "11000")
+    return res
+      .status(422)
+      .json({ errors: [{ message: `${Object.keys(err.keyPattern)} is already exists` }] });
+  // unhandled multer error
+  if (err instanceof MulterError)
+    return res.status(400).json({ errors: [{ message: `${err.field} is invalid` }] });
+  // JWT invalid token
+  if (err.name === "JsonWebTokenError")
+    return res.status(401).json({ errors: [{ message: "invalid token" }] });
+  // JWT expired token
+  if (err.name === "TokenExpiredError")
+    return res.status(401).json({ errors: [{ message: "expired token" }] });
+  // unHandled error
+  res.status(500).json({ errors: [{ message: "server error" }] });
+};

package/src/types/JwtPayload.ts

@@ -0,0 +1,3 @@
+export interface IjwtPayload {
+  id: string;
+}

package/src/types/Pagination.ts

@@ -0,0 +1,7 @@
+export interface Ipagination {
+  currentPage: number;
+  limit: number;
+  numberOfPages: number;
+  nextPage: number;
+  previousPage: number;
+}

package/src/types/UrlQuery.ts

@@ -0,0 +1,9 @@
+export interface IurlQuery {
+  limit?: string;
+  page?: string;
+  sort?: string;
+  fields?: string;
+  keyword?: string;
+  price?: string;
+  ratingAverage?: string;
+}

package/src/types/auth/User.ts

@@ -0,0 +1,27 @@
+import { Types } from "mongoose";
+
+export interface Iuser {
+  id: string;
+  googleId?: string;
+  appleId?: string;
+  name?: string;
+  phoneNumber: { key: string; number: string };
+  username: string;
+  password?: string;
+  verificationCode?: { code: string; expireAt: Date };
+  token?: string;
+  profileImage?: string;
+  coverImage?: string;
+  location?: { lat: number; lng: number };
+  categroy?: Types.ObjectId;
+  acceptedProjectsCounter: number;
+  profileViews: number;
+  about?: string;
+  isOnline: boolean;
+  isAvaliableToInstantProjects: boolean;
+  pricePerHour?: number;
+  plan: Types.ObjectId;
+  hasVerificationPadge: boolean;
+  avaliableContracts: number;
+  rate: { ratersCounter: number; totalRates: number };
+}

package/src/types/auth/endpoints.ts

@@ -0,0 +1,12 @@
+import { IjwtPayload } from "./../JwtPayload";
+import { RequestHandler, Request, Response } from "express";
+import { Iuser } from "./User";
+
+// param, res, req, query
+export interface IsigninHandler
+  extends RequestHandler<
+    undefined,
+    { token: string },
+    Partial<Pick<Iuser, "username" | "phoneNumber" | "password">>,
+    undefined
+  > {}

package/src/utils/api-feature.ts

@@ -0,0 +1,89 @@
+import { Model, Query, Document } from "mongoose";
+import { Ipagination } from "../types/Pagination";
+import { IurlQuery } from "../types/UrlQuery";
+
+export class Api_Feature {
+  mongooseQuery: Query<Document[], Document, Model<Document>>;
+  queryString: IurlQuery;
+  filterQuery: Record<string, any>;
+  paginateResult: Partial<Ipagination>;
+
+  constructor(
+    mongooseQuery: Query<Document[], Document, Model<Document>>,
+    queryString: Partial<IurlQuery>
+  ) {
+    this.mongooseQuery = mongooseQuery;
+    this.queryString = queryString;
+    this.paginateResult = {};
+    this.filterQuery = {};
+  }
+
+  filter(): this {
+    const queryValues: any = { ...this.queryString };
+    const expectedQuery: string[] = ["limit", "fields", "page", "keyword", "sort"];
+    expectedQuery.forEach((val) => delete queryValues[val]);
+
+    let queryStr = JSON.stringify(queryValues);
+    queryStr = queryStr.replace(/\b(gte|ge|eq|lt|lte)\b/g, (match) => `$${match}`);
+
+    if (this.queryString.keyword) {
+      this.filterQuery = JSON.parse(queryStr);
+    } else {
+      this.mongooseQuery = this.mongooseQuery.find(JSON.parse(queryStr));
+    }
+    return this;
+  }
+
+  sort(): this {
+    if (this.queryString.sort) {
+      const sortBy = this.queryString.sort.split(",").join(" ");
+      this.mongooseQuery = this.mongooseQuery.sort(sortBy);
+    } else {
+      this.mongooseQuery = this.mongooseQuery.sort("-createdAt");
+    }
+    return this;
+  }
+
+  limitFields(): this {
+    if (this.queryString.fields) {
+      const fields = this.queryString.fields.split(",").join(" ");
+      this.mongooseQuery = this.mongooseQuery.select(fields);
+    } else {
+      this.mongooseQuery = this.mongooseQuery.select("-__v");
+    }
+    return this;
+  }
+
+  search(fieldName: string): this {
+    // search by keyword by name
+    if (this.queryString.keyword) {
+      this.filterQuery[fieldName] = { $regex: this.queryString.keyword, $options: "i" };
+      this.mongooseQuery = this.mongooseQuery.find(this.filterQuery);
+    }
+
+    return this;
+  }
+
+  pagination(documentCount: number): this {
+    const page: number = +(this.queryString.page || 1);
+    const limit: number = +(this.queryString.limit || 10);
+    const skip: number = (page - 1) * limit;
+    const endPageIndex: number = page * limit;
+
+    const pagination: Partial<Ipagination> = {};
+    pagination.currentPage = page;
+    pagination.limit = limit;
+    pagination.numberOfPages = Math.ceil(documentCount / limit);
+    if (endPageIndex < documentCount) {
+      pagination.nextPage = page + 1;
+    }
+
+    if (skip > 0) {
+      pagination.previousPage = page - 1;
+    }
+
+    this.mongooseQuery = this.mongooseQuery.skip(skip).limit(limit);
+    this.paginateResult = pagination;
+    return this;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2016",
+    "module": "commonjs",
+    "rootDir": "./src",
+    "declaration": true,
+    "outDir": "./build",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "custom.d.ts"]
+}