@extk/expressive 0.1.0

package/dist/index.js

@@ -0,0 +1,565 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  ApiErrorResponse: () => ApiErrorResponse,
+  ApiResponse: () => ApiResponse,
+  BadRequestError: () => BadRequestError,
+  DuplicateError: () => DuplicateError,
+  FileTooBigError: () => FileTooBigError,
+  ForbiddenError: () => ForbiddenError,
+  InternalError: () => InternalError,
+  InvalidCredentialsError: () => InvalidCredentialsError,
+  InvalidFileTypeError: () => InvalidFileTypeError,
+  NotFoundError: () => NotFoundError,
+  SWG: () => SWG,
+  SchemaValidationError: () => SchemaValidationError,
+  TokenExpiredError: () => TokenExpiredError,
+  TooManyRequestsError: () => TooManyRequestsError,
+  UserUnauthorizedError: () => UserUnauthorizedError,
+  bootstrap: () => bootstrap,
+  createLogger: () => createLogger,
+  createReqSnapshot: () => createReqSnapshot,
+  getDefaultConsoleLogger: () => getDefaultConsoleLogger,
+  getDefaultFileLogger: () => getDefaultFileLogger,
+  getEnvVar: () => getEnvVar,
+  getTmpDir: () => getTmpDir,
+  getTmpPath: () => getTmpPath,
+  isDev: () => isDev,
+  isProd: () => isProd,
+  parseDefaultPagination: () => parseDefaultPagination,
+  parseIdOrFail: () => parseIdOrFail,
+  parsePositiveInteger: () => parsePositiveInteger,
+  slugify: () => slugify
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/expressive.ts
+var import_express = __toESM(require("express"));
+var import_helmet = __toESM(require("helmet"));
+var import_morgan = __toESM(require("morgan"));
+var import_qs = __toESM(require("qs"));
+var import_swagger_ui_express = __toESM(require("swagger-ui-express"));
+
+// src/swagger.ts
+var buildSwaggerBuilder = (swaggerDoc) => {
+  return {
+    swaggerBuilder: () => {
+      return {
+        withInfo(info) {
+          swaggerDoc.info = info;
+          return this;
+        },
+        withServers(servers) {
+          swaggerDoc.servers = servers;
+          return this;
+        },
+        withSecuritySchemes(schemes) {
+          swaggerDoc.components.securitySchemes = schemes;
+          return this;
+        },
+        withSchemas(schemas) {
+          swaggerDoc.components.schemas = schemas;
+          return this;
+        },
+        withDefaultSecurity(globalAuthMethods) {
+          swaggerDoc.security = globalAuthMethods;
+          return this;
+        },
+        get() {
+          return swaggerDoc;
+        }
+      };
+    }
+  };
+};
+var securitySchemes = {
+  BasicAuth: () => ({
+    type: "http",
+    scheme: "basic"
+  }),
+  BearerAuth: () => ({
+    type: "http",
+    scheme: "bearer"
+  }),
+  ApiKeyAuth: (headerName) => ({
+    type: "apiKey",
+    in: "header",
+    name: headerName
+  }),
+  OpenID: (openIdConnectUrl) => ({
+    type: "openIdConnect",
+    openIdConnectUrl
+  }),
+  OAuth2: (authorizationUrl, tokenUrl, scopes) => ({
+    type: "oauth2",
+    flows: {
+      authorizationCode: {
+        authorizationUrl,
+        tokenUrl,
+        scopes
+      }
+    }
+  })
+};
+var securityRegistry = {};
+var security = (name) => {
+  if (!securityRegistry[name]) {
+    securityRegistry[name] = { [name]: [] };
+  }
+  return securityRegistry[name];
+};
+function jsonSchema(schema) {
+  return {
+    content: {
+      "application/json": {
+        schema
+      }
+    }
+  };
+}
+function jsonSchemaRef(name) {
+  return jsonSchema({ $ref: `#/components/schemas/${name}` });
+}
+function param(inP, id, schema, required = true, description = "", name) {
+  return {
+    in: inP,
+    name: name ?? id,
+    desciption: description,
+    required,
+    schema
+  };
+}
+function pathParam(id, schema, required = true, description = "", name) {
+  return param("path", id, schema, required, description, name);
+}
+function queryParam(id, schema, required = true, description = "", name) {
+  return param("query", id, schema, required, description, name);
+}
+function headerParam(id, schema, required = true, description = "", name) {
+  return param("headers", id, schema, required, description, name);
+}
+function convertExpressPath(path2) {
+  return path2.replace(/:([a-zA-Z0-9_*]+)/g, "{$1}");
+}
+function tryParsePathParameters(path2) {
+  const matches = path2.match(/(?<={)[^}]+(?=})/g);
+  if (!matches) {
+    return [];
+  }
+  return matches.map((pp) => pathParam(pp, { type: "string" }));
+}
+var SWG = {
+  param,
+  pathParam,
+  queryParam,
+  headerParam,
+  jsonSchema,
+  jsonSchemaRef,
+  security,
+  securitySchemes
+};
+
+// src/expressive.ts
+function buildExpressive(container, swaggerDoc) {
+  return {
+    expressiveServer(configs) {
+      const { options } = configs;
+      const app = configs.app ?? (0, import_express.default)();
+      app.use((0, import_helmet.default)(options?.helmet ?? {}));
+      app.set("query parser", function(str) {
+        return import_qs.default.parse(str, { decoder(s) {
+          return decodeURIComponent(s);
+        } });
+      });
+      app.use((0, import_morgan.default)(
+        options?.morgan?.format ?? ":req[x-real-ip] :method :url :status :res[content-length] - :response-time ms",
+        options?.morgan?.options ?? { stream: { write(message) {
+          container.logger.info(message.trim());
+        } } }
+      ));
+      app.use(configs.swagger.path, import_swagger_ui_express.default.serve, import_swagger_ui_express.default.setup(configs.swagger.doc));
+      return app;
+    },
+    expressiveRouter(configs) {
+      const router = import_express.default.Router();
+      return {
+        router,
+        addRoute(context, ...handlers) {
+          router[context.method](context.path, ...handlers);
+          const {
+            pathOverride,
+            pathParameters,
+            headerParameters,
+            queryParameters,
+            ...pathItemConfig
+          } = context.oapi || {};
+          const route = pathOverride ?? convertExpressPath(context.path);
+          const pathItem = {
+            // -- defaults --
+            responses: {},
+            // has to be defined or else responses are not documented... ¯\_(ツ)_/¯
+            // -- group defaults --
+            ...configs?.oapi || {},
+            // -- overrides --
+            ...pathItemConfig || {},
+            parameters: [
+              // ...(contract.pathParameters || []),
+              ...headerParameters || [],
+              ...queryParameters || []
+            ]
+          };
+          if (pathParameters?.length) {
+            pathItem.parameters.push(...pathParameters);
+          } else {
+            pathItem.parameters.push(...tryParsePathParameters(route));
+          }
+          swaggerDoc.paths[route] = {
+            [context.method]: pathItem
+          };
+          return router;
+        }
+      };
+    }
+  };
+}
+
+// src/env.ts
+var import_dotenv = __toESM(require("dotenv"));
+import_dotenv.default.config();
+function isDev() {
+  return getEnvVar("ENV") === "dev";
+}
+function isProd() {
+  return getEnvVar("ENV") === "prod";
+}
+function getEnvVar(configName) {
+  const config = process.env[configName];
+  if (!config) {
+    throw new Error(`Missing config '${configName}'`);
+  }
+  return config;
+}
+
+// src/errors.ts
+var ApiError = class extends Error {
+  code;
+  httpStatusCode;
+  data;
+  constructor(message, httpStatusCode, errorCode) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = errorCode;
+    this.httpStatusCode = httpStatusCode;
+  }
+  setData(data) {
+    this.data = data;
+    return this;
+  }
+};
+var NotFoundError = class extends ApiError {
+  constructor(message = "Resource not found") {
+    super(message, 404, "NOT_FOUND");
+  }
+};
+var DuplicateError = class extends ApiError {
+  constructor(message = "Duplicate entry") {
+    super(message, 409, "DUPLICATE_ENTRY");
+  }
+};
+var BadRequestError = class extends ApiError {
+  constructor(message = "Bad request") {
+    super(message, 400, "BAD_REQUEST");
+  }
+};
+var SchemaValidationError = class extends ApiError {
+  constructor(message = "Failed to validate Schema") {
+    super(message, 400, "SCHEMA_VALIDATION_ERROR");
+  }
+};
+var FileTooBigError = class extends ApiError {
+  constructor() {
+    super("File too big", 400, "FILE_TOO_BIG");
+  }
+};
+var InvalidFileTypeError = class extends ApiError {
+  constructor() {
+    super("Invalid file type", 400, "INVALID_FILE_TYPE");
+  }
+};
+var InvalidCredentialsError = class extends ApiError {
+  constructor() {
+    super("Invalid credentials", 401, "INVALID_CREDENTIALS");
+  }
+};
+var InternalError = class extends ApiError {
+  constructor() {
+    super("Internal error", 500, "INTERNAL_ERROR");
+  }
+};
+var TooManyRequestsError = class extends ApiError {
+  constructor(message = "Too many requests") {
+    super(message, 429, "TOO_MANY_REQUESTS");
+  }
+};
+var ForbiddenError = class extends ApiError {
+  constructor(message = "Action not allowed") {
+    super(message, 403, "FORBIDDEN");
+  }
+};
+var TokenExpiredError = class extends ApiError {
+  constructor(message = "Token Expired") {
+    super(message, 401, "TOKEN_EXPIRED");
+  }
+};
+var UserUnauthorizedError = class extends ApiError {
+  constructor(message = "User unauthorized") {
+    super(message, 401, "USER_UNAUTHORIZED");
+  }
+};
+
+// src/response/ApiErrorResponse.ts
+var ApiErrorResponse = class {
+  status = "error";
+  message;
+  errorCode;
+  errors;
+  constructor(message, errorCode, errors) {
+    this.message = message;
+    this.errorCode = errorCode;
+    this.errors = errors;
+  }
+};
+
+// src/common.ts
+var import_path = __toESM(require("path"));
+function parsePositiveInteger(v, defaultValue, max) {
+  const value = Number(v);
+  return Number.isInteger(value) && value > 0 && (!max || value <= max) ? value : defaultValue;
+}
+function parseIdOrFail(v) {
+  const value = Number(v);
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new ApiError("Invalid Id", 400, "INVALID_ID");
+  }
+  return value;
+}
+function slugify(text) {
+  return text.toString().normalize("NFKD").toLowerCase().trim().replace(/[\s\n_+.]/g, "-").replace(/--+/g, "-");
+}
+function getTmpDir() {
+  return import_path.default.resolve("tmp");
+}
+function getTmpPath(...steps) {
+  return import_path.default.join(getTmpDir(), ...steps);
+}
+function parseDefaultPagination(query) {
+  const limit = parsePositiveInteger(query.limit, 50, 100);
+  const page = parsePositiveInteger(query.page, 1, 1e3);
+  const offset = (page - 1) * limit;
+  return { limit, offset };
+}
+function createReqSnapshot(req) {
+  return {
+    query: req.query,
+    path: req.path,
+    method: req.method,
+    userId: req?.user?.id
+  };
+}
+
+// src/middleware/errorHandlerMiddleware.ts
+var buildErrorHandlerMiddleware = (container) => {
+  const { logger, alertHandler } = container;
+  return {
+    getErrorHandlerMiddleware: (errorMapper) => {
+      return async (err, req, res, _next) => {
+        let finalError;
+        const customMappedError = errorMapper && errorMapper(err);
+        if (customMappedError) {
+          finalError = customMappedError;
+          logger.error("%s\n%o", finalError.message, finalError.data);
+        } else if (err.name === "SyntaxError" && err.type === "entity.parse.failed") {
+          logger.error("%s", err);
+          finalError = new BadRequestError("Invalid json format");
+        } else if (err instanceof ApiError) {
+          logger.error("%s", err);
+          finalError = err;
+        } else {
+          logger.error("Error: %s", err);
+          if (err.cause) {
+            logger.error("Cause: %s", err.cause);
+          }
+          if (alertHandler) {
+            alertHandler(err, createReqSnapshot(req));
+          }
+          finalError = new InternalError();
+          if (!isProd()) {
+            finalError.data = { name: err.name, message: err.message, stack: err.stack, cause: err.cause };
+          }
+        }
+        res.status(finalError.httpStatusCode).json(new ApiErrorResponse(finalError.message, finalError.code, finalError.data));
+      };
+    }
+  };
+};
+
+// src/middleware/notFoundMiddleware.ts
+var notFoundMiddleware = (_req, res, _next) => {
+  res.status(404).send("\xAF\\_(\u30C4)_/\xAF").end();
+};
+
+// src/logger.ts
+var import_winston = __toESM(require("winston"));
+var import_winston_daily_rotate_file = __toESM(require("winston-daily-rotate-file"));
+var loggerRegistry = {};
+var defaultFormat = import_winston.default.format.combine(
+  import_winston.default.format.timestamp({ format: "DD/MM/YYYY HH:mm:ss" }),
+  import_winston.default.format.splat(),
+  // String interpolation splat for %d %s-style messages.
+  import_winston.default.format.errors({ stack: true }),
+  import_winston.default.format.printf(({ level, message, timestamp, stack }) => `${timestamp}[${level.toUpperCase()}]: ${stack || message}`)
+);
+var consoleTransport = new import_winston.default.transports.Console({
+  handleExceptions: true
+});
+var createFileLogger = (filename) => {
+  const logger = import_winston.default.createLogger({
+    format: defaultFormat,
+    transports: [
+      new import_winston_daily_rotate_file.default({
+        level: "debug",
+        filename: `./logs/${filename}-%DATE%.log`,
+        handleExceptions: true,
+        // exitOnError: false, // do not exit on handled exceptions
+        datePattern: "YYYY-MM-DD",
+        zippedArchive: true,
+        auditFile: "./logs/audit.json",
+        maxSize: "20m",
+        maxFiles: isProd() ? "30d" : "1d"
+        // format: defaultFormat,
+        // the nested 'format' field causes issues with logging errors;
+        // use the 'format' field on logger, instead of transport;
+      })
+    ]
+  });
+  if (isDev()) {
+    logger.add(consoleTransport);
+  }
+  return logger;
+};
+var createLogger = import_winston.default.createLogger;
+var getDefaultFileLogger = (name = "app") => {
+  if (!loggerRegistry[name]) {
+    loggerRegistry[name] = createFileLogger(name.toString());
+  }
+  return loggerRegistry[name];
+};
+var getDefaultConsoleLogger = (name = "console") => {
+  if (!loggerRegistry[name]) {
+    loggerRegistry[name] = import_winston.default.createLogger({
+      format: defaultFormat,
+      transports: [
+        consoleTransport
+      ]
+    });
+  }
+  return loggerRegistry[name];
+};
+
+// src/response/ApiResponse.ts
+var ApiResponse = class {
+  status = "ok";
+  result;
+  constructor(result) {
+    this.result = result;
+  }
+};
+
+// src/index.ts
+function bootstrap(container) {
+  const swaggerDoc = {
+    openapi: "3.1.0",
+    // TODO
+    info: {},
+    paths: {},
+    components: {}
+  };
+  return {
+    ...buildExpressive(container, swaggerDoc),
+    ...buildSwaggerBuilder(swaggerDoc),
+    ...buildErrorHandlerMiddleware(container),
+    notFoundMiddleware,
+    silently: (fn, reqSnapshot) => {
+      fn().catch((e) => {
+        if (container.alertHandler && e instanceof Error) {
+          container.alertHandler(e, reqSnapshot);
+        } else {
+          container.logger.error(e);
+        }
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  ApiErrorResponse,
+  ApiResponse,
+  BadRequestError,
+  DuplicateError,
+  FileTooBigError,
+  ForbiddenError,
+  InternalError,
+  InvalidCredentialsError,
+  InvalidFileTypeError,
+  NotFoundError,
+  SWG,
+  SchemaValidationError,
+  TokenExpiredError,
+  TooManyRequestsError,
+  UserUnauthorizedError,
+  bootstrap,
+  createLogger,
+  createReqSnapshot,
+  getDefaultConsoleLogger,
+  getDefaultFileLogger,
+  getEnvVar,
+  getTmpDir,
+  getTmpPath,
+  isDev,
+  isProd,
+  parseDefaultPagination,
+  parseIdOrFail,
+  parsePositiveInteger,
+  slugify
+});