page2pdf_server 1.0.0

package/src/configEnv/index.ts

@@ -0,0 +1,62 @@
+import pkg from "../../package.json";
+
+// https://github.com/motdotla/dotenv#how-do-i-use-dotenv-with-import
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require("dotenv").config();
+
+//提取独立的配置文件的设置参数：
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const config = require("config");
+const base_path = config.get("base_path");
+const default_file = config.get("default_file");
+console.log("默认合并输出文件： " + base_path + "/" + default_file + ".pdf");
+
+//pkg.是项目工程的配置；
+const CONFIG = {
+  APP: {
+    NAME: pkg.name,
+    VERSION: pkg.version,
+    VER: `v${pkg.version[0]}`,
+    DESCRIPTION: pkg.description,
+    AUTHORS: pkg.authors,
+    HOST: process.env.APP_HOST,
+    BASE_URL: process.env.API_BASE_URL,
+    PORT: process.env.NODE_ENV === "test" ? 8888 : process.env.PORT || 8080,
+    ENV: process.env.NODE_ENV,
+    PATH: base_path,
+    MERGE: default_file,
+  },
+  SERVER: {
+    TIMEOUT: 60 * 60 * 1000, // 60 *60秒没结果的
+  },
+  LOG: {
+    PATH: process.env.LOGGING_DIR || "logs",
+    LEVEL: process.env.LOGGING_LEVEL || "info",
+    MAX_FILES: process.env.LOGGING_MAX_FILES || 5,
+  },
+  AUTH: {
+    SALT_ROUNDS: process.env.SALT_ROUNDS || "11",
+    ACCESS_TOKEN_EXPIRE: process.env.ACCESS_TOKEN_DURATION || "300000",
+    REFRESH_TOKEN_EXPIRE: process.env.REFRESH_TOKEN_DURATION || "86400000",
+    ACCESS_TOKEN_SALT: process.env.ACCESS_TOKEN_SALT,
+    REFRESH_TOKEN_SALT: process.env.REFRESH_TOKEN_SALT,
+  },
+  AWS: {
+    ACCESS_KEY: process.env.AWS_ACCESS_KEY,
+    SECRET_KEY: process.env.AWS_SECRET_KEY,
+    REGION: process.env.AWS_REGION,
+    S3: {
+      PATH: process.env.S3_BUCKET_PATH,
+      BUCKET_NAME: process.env.S3_BUCKET_NAME,
+    },
+    COGNITO: {
+      USER_POOL_ID: process.env.COGNITO_USER_POOL_ID,
+      CLIENT_ID: process.env.COGNITO_CLIENT_ID,
+    },
+  },
+  EXTERNAL: {
+    API_KEY: process.env.API_KEY,
+  },
+} as const;
+
+export default CONFIG;

package/src/db/home.ts

@@ -0,0 +1,14 @@
+import AppInformation from "@/types/response/AppInformation";
+import CONFIG from "@/configEnv";
+import { getAppInfoQuery } from "@/types/request/home";
+
+export class HomeDAO {
+  get = (key?: getAppInfoQuery): Promise<AppInformation | any> => {
+    if (!key) {
+      return Promise.resolve(CONFIG.APP);
+    }
+    const upperKey = key.toUpperCase() as keyof typeof CONFIG.APP;
+
+    return Promise.resolve({ [upperKey]: CONFIG.APP[upperKey] });
+  };
+}

package/src/helpers/apiResponse.ts

@@ -0,0 +1,10 @@
+import HttpStatus, { OK } from "http-status/lib";
+import { ApiSuccessResponse } from "@/types/response";
+
+export const apiResponse = <T>(data?: T): ApiSuccessResponse<T> => {
+  return {
+    status: OK,
+    message: HttpStatus[OK] as string,
+    data,
+  };
+};

package/src/helpers/dataSanitizers.ts

@@ -0,0 +1,31 @@
+import { Result, ValidationChain, validationResult } from "express-validator";
+import { Middleware as ValidatorMiddleware } from "express-validator/src/base";
+import ValidationError from "./error/ValidationError";
+
+type MultiValidatorChain = ValidatorMiddleware & {
+  run: (req: Request) => Promise<Result>;
+};
+
+const catchValidatorError = (req: Req, _: Res, next: NextFn): void => {
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    const validationErrors = errors
+      .array()
+      .reduce(
+        (
+          obj: Record<string, string>,
+          error: Record<string, any>,
+        ): Record<string, any> => {
+          obj[error.param] = error.msg;
+          return obj;
+        },
+        {},
+      );
+    throw new ValidationError(validationErrors);
+  }
+  next();
+};
+
+export const sanitizer = (
+  validator: (ValidationChain | MultiValidatorChain)[],
+) => [...validator, catchValidatorError];

package/src/helpers/error/ApiError.ts

@@ -0,0 +1,25 @@
+import HttpStatus, { INTERNAL_SERVER_ERROR } from "http-status/lib";
+
+class APIError extends Error {
+  readonly status: number;
+  readonly message: string;
+  readonly error: any | undefined;
+
+  constructor(message: string | null, error?: any) {
+    super();
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.status = INTERNAL_SERVER_ERROR;
+    this.message = message || (HttpStatus[INTERNAL_SERVER_ERROR] as string);
+    if (error && error instanceof Error) {
+      this.error = {
+        type: error?.name,
+        message: error?.message,
+        stack: error?.stack,
+      };
+    }
+
+    Error.captureStackTrace(this);
+  }
+}
+
+export default APIError;

package/src/helpers/error/ForbiddenError.ts

@@ -0,0 +1,15 @@
+import { FORBIDDEN } from "http-status/lib";
+
+class ForbiddenError {
+  readonly status: number;
+  readonly message: string;
+
+  constructor(message: string) {
+    Object.setPrototypeOf(this, new.target.prototype);
+
+    this.status = FORBIDDEN;
+    this.message = message;
+  }
+}
+
+export default ForbiddenError;

package/src/helpers/error/NotFoundException.ts

@@ -0,0 +1,15 @@
+import HttpStatus, { NOT_FOUND } from "http-status/lib";
+
+class NotFoundException {
+  readonly status: number;
+  readonly message: string;
+
+  constructor() {
+    Object.setPrototypeOf(this, new.target.prototype);
+
+    this.status = NOT_FOUND;
+    this.message = HttpStatus[NOT_FOUND] as string;
+  }
+}
+
+export default NotFoundException;

package/src/helpers/error/TimeOutError.ts

@@ -0,0 +1,20 @@
+import httpStatus, { REQUEST_TIMEOUT } from "http-status/lib";
+import CONFIG from "@/configEnv";
+
+class TimeOutError {
+  readonly status: number;
+  readonly message: string;
+  readonly timeout: string | number;
+  readonly path: string;
+
+  constructor(path: string) {
+    Object.setPrototypeOf(this, new.target.prototype);
+
+    this.status = REQUEST_TIMEOUT;
+    this.message = httpStatus[REQUEST_TIMEOUT] as string;
+    this.timeout = CONFIG.SERVER.TIMEOUT;
+    this.path = path;
+  }
+}
+
+export default TimeOutError;

package/src/helpers/error/UnauthorizedError.ts

@@ -0,0 +1,15 @@
+import HttpStatus, { UNAUTHORIZED } from "http-status/lib";
+
+class UnauthorizedError {
+  readonly status: number;
+  readonly message: string;
+
+  constructor(message: string) {
+    Object.setPrototypeOf(this, new.target.prototype);
+
+    this.status = UNAUTHORIZED;
+    this.message = message || (HttpStatus[UNAUTHORIZED] as string);
+  }
+}
+
+export default UnauthorizedError;

package/src/helpers/error/ValidationError.ts

@@ -0,0 +1,20 @@
+import HttpStatus, { BAD_REQUEST } from "http-status/lib";
+
+class ValidationError extends Error {
+  readonly status: number;
+  readonly message: string;
+  readonly details: Record<string, any>;
+
+  constructor(validationErrors: Record<string, any>) {
+    super();
+    Object.setPrototypeOf(this, new.target.prototype);
+
+    this.status = BAD_REQUEST;
+    this.message = HttpStatus[BAD_REQUEST] as string;
+    this.details = validationErrors;
+
+    Error.captureStackTrace(this);
+  }
+}
+
+export default ValidationError;

package/src/helpers/error/index.ts

@@ -0,0 +1,15 @@
+import APIError from "./ApiError";
+import ValidationError from "./ValidationError";
+import ForbiddenError from "./ForbiddenError";
+import UnauthorizedError from "./UnauthorizedError";
+import NotFoundException from "./NotFoundException";
+import TimeOutError from "./TimeOutError";
+
+export {
+  APIError,
+  ValidationError,
+  ForbiddenError,
+  UnauthorizedError,
+  NotFoundException,
+  TimeOutError,
+};

package/src/helpers/index.ts

@@ -0,0 +1,2 @@
+export { expressPinoLogger, exitLog } from "./loggers";
+export { sanitizer } from "./dataSanitizers";

package/src/helpers/loggers.ts

@@ -0,0 +1,73 @@
+import httpStatus from "http-status/lib";
+import expressPino from "express-pino-logger";
+import { hidePassword } from "@/utils/auth";
+
+const { OK, BAD_REQUEST, SERVER_ERROR } = httpStatus;
+
+// More info: https://github.com/pinojs/express-pino-logger
+export const expressPinoLogger = () =>
+  expressPino({
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: true,
+      },
+    },
+    customLogLevel(res, err) {
+      const status = res.statusCode!;
+      if (status >= 400 && status < 500) {
+        return "warn";
+      }
+      if (status >= 500 || err) {
+        return "error";
+      }
+      return "silent";
+    },
+    customErrorMessage: (err) => ` : ${err}`,
+    customSuccessMessage(res) {
+      const status = res.statusCode!;
+      if (status >= 400 && status < 500) {
+        return `${status || BAD_REQUEST} : ${httpStatus[status || 400]}`;
+      }
+      if (status >= 500) {
+        return `${status || SERVER_ERROR} : ${httpStatus[status || 500]}`;
+      }
+      return `${OK} : ${httpStatus[200].toUpperCase()}`;
+    },
+    serializers: {
+      req: (req) => {
+        // console.log('[ R E Q U E S T ] => ', req.raw);
+        const {
+          method,
+          url,
+          headers: { host },
+        } = req;
+        return {
+          origin: host,
+          method,
+          url,
+          query: req.query,
+          params: req.params,
+          body: hidePassword({ ...req.raw.body }),
+        };
+      },
+      res: (res) => {
+        // console.log("[ R E S P O N S E ] => ", res);
+        return {
+          status: res.statusCode,
+        };
+      },
+      err: (err) => `${err.type} : ${err.message}`,
+    },
+  });
+
+export const exitLog = (err: any, evt: string) => {
+  if (err) {
+    process.stdout.write(`\n\n[!ERROR][${evt}] => ${err}\n\n`);
+  } else {
+    process.stdout.write(`\n\n![${evt}] EVENT CAUSE EXIT\n\n`);
+  }
+
+  process.exit(err ? 1 : 0);
+};

package/src/index.ts

@@ -0,0 +1,13 @@
+// ! Don't convert require into import
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require("module-alias").addAlias("@", __dirname);
+
+import { createApp } from "./app";
+import { startServer } from "./server";
+
+if (process.env.NODE_ENV !== "test") {
+  const app = createApp();
+  startServer(app);
+}
+
+//关键文档Chrome DevTools Protocol资料， https://chromedevtools.github.io/devtools-protocol/tot/Page

package/src/middlewares/errorHandler.ts

@@ -0,0 +1,52 @@
+import { NextFunction, Request, Response } from "express";
+
+import HttpStatus, {
+  NOT_FOUND,
+  INTERNAL_SERVER_ERROR,
+  REQUEST_TIMEOUT,
+} from "http-status/lib";
+import { TimeOutError } from "@/helpers/error";
+
+/**
+ * @description Error response middleware for 404 not found. This middleware function should be at the very bottom of the stack.
+ * @param req Express.Request
+ * @param res Express.Response
+ * @param _next Express.NextFunction
+ */
+export const notFoundError = (
+  req: Request,
+  res: Response,
+  _next: NextFunction,
+) => {
+  res.status(NOT_FOUND).json({
+    error: {
+      code: NOT_FOUND,
+      message: HttpStatus[NOT_FOUND],
+      path: req.originalUrl,
+    },
+  });
+};
+
+/**
+ * @description Generic error response middleware for validation and internal server errors.
+ * @param {*} err
+ * @param {object}   req Express.Request
+ * @param {object}   res Express.Response
+ * @param {function} next Express.NextFunction
+ */
+export const genericErrorHandler = (
+  err: any,
+  req: Request,
+  res: Response,
+  _next: NextFunction,
+) => {
+  let resCode: number = err.status || INTERNAL_SERVER_ERROR;
+  let resBody = err;
+
+  if (err.code === "ETIMEDOUT") {
+    resCode = REQUEST_TIMEOUT;
+    resBody = new TimeOutError(req.originalUrl);
+  }
+
+  res.status(resCode).json(resBody);
+};