@avleon/core 0.0.20 → 0.0.24

package/src/index.ts

@@ -0,0 +1,30 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import * as sw from "./swagger-schema";
+export * from "./icore";
+export * from "./testing";
+export { inject, validateRequestBody,pick, exclude } from "./helpers";
+export * from "./decorators";
+export * from "./middleware";
+export * from "./config";
+export * from "./openapi";
+export * from "./map-types";
+export * from "./response";
+export * from "./exceptions";
+export * from "./validator-extend";
+export * from "./validation";
+export * from "./environment-variables";
+export * from "./collection";
+export * from "./queue";
+export * from "./utils/hash";
+export * from "./multipart";
+export * from "./file-storage";
+export * from "./logger";
+
+export const GetSchema = sw.generateSwaggerSchema;
+
+export { default as Container } from "./container";

package/src/logger.ts

@@ -0,0 +1,72 @@
+import pino from "pino";
+import { AppService } from "./decorators";
+
+@AppService
+export class LoggerService {
+  private logger: pino.Logger;
+
+  constructor() {
+    this.logger = pino({
+      level: process.env.LOG_LEVEL || "info",
+      transport: {
+        target: "pino-pretty",
+        options: {
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname",
+        },
+      },
+    });
+  }
+
+  getLogger(): pino.Logger {
+    return this.logger;
+  }
+
+  info(message: string, obj?: any): void {
+    if (obj) {
+      this.logger.info(obj, message);
+    } else {
+      this.logger.info(message);
+    }
+  }
+
+  error(message: string, obj?: any): void {
+    if (obj) {
+      this.logger.error(obj, message);
+    } else {
+      this.logger.error(message);
+    }
+  }
+
+  warn(message: string, obj?: any): void {
+    if (obj) {
+      this.logger.warn(obj, message);
+    } else {
+      this.logger.warn(message);
+    }
+  }
+
+  debug(message: string, obj?: any): void {
+    if (obj) {
+      this.logger.debug(obj, message);
+    } else {
+      this.logger.debug(message);
+    }
+  }
+
+  fatal(message: string, obj?: any): void {
+    if (obj) {
+      this.logger.fatal(obj, message);
+    } else {
+      this.logger.fatal(message);
+    }
+  }
+
+  trace(message: string, obj?: any): void {
+    if (obj) {
+      this.logger.trace(obj, message);
+    } else {
+      this.logger.trace(message);
+    }
+  }
+}

package/src/map-types.ts

@@ -0,0 +1,159 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+//
+type Constructor<T = any> = new (...args: any[]) => T;
+
+export function PartialType<T>(
+  BaseClass: Constructor<T>,
+): Constructor<Partial<T>> {
+  const baseProperties: string[] = [];
+  let currentPrototype = BaseClass.prototype;
+
+  // Collect properties from the base class (including inherited ones)
+  while (currentPrototype && currentPrototype !== Object.prototype) {
+    const properties = Object.getOwnPropertyNames(currentPrototype).filter(
+      (prop) => prop !== "constructor", // Exclude the constructor
+    );
+
+    // Retrieve metadata for each property
+    properties.forEach((key) => {
+      // Check if the property has type metadata (design:type)
+      const designType = Reflect.getMetadata(
+        "design:type",
+        currentPrototype,
+        key,
+      );
+      if (designType) {
+        baseProperties.push(key);
+      }
+
+      // Retrieve validation metadata (class-validator)
+      const validationMetadata = Reflect.getMetadataKeys(currentPrototype, key);
+      validationMetadata.forEach((metadataKey) => {});
+    });
+
+    currentPrototype = Object.getPrototypeOf(currentPrototype); // Move up the prototype chain
+  }
+
+  class PartialClass {}
+
+  // Define properties as optional and copy metadata
+  baseProperties.forEach((key) => {
+    const propertyType = Reflect.getMetadata(
+      "design:type",
+      BaseClass.prototype,
+      key,
+    );
+    Reflect.defineMetadata(
+      "design:type",
+      propertyType,
+      PartialClass.prototype,
+      key,
+    );
+
+    // Propagate class-validator metadata to the new class
+    const validationMetadataKeys =
+      Reflect.getMetadataKeys(BaseClass.prototype, key) || [];
+    validationMetadataKeys.forEach((metadataKey) => {
+      const metadataValue = Reflect.getMetadata(
+        metadataKey,
+        BaseClass.prototype,
+        key,
+      );
+      Reflect.defineMetadata(
+        metadataKey,
+        metadataValue,
+        PartialClass.prototype,
+        key,
+      );
+    });
+  });
+
+  // Copy other metadata from the base class (non-property metadata)
+  Reflect.getMetadataKeys(BaseClass.prototype).forEach((key) => {
+    const metadataValue = Reflect.getMetadata(key, BaseClass.prototype);
+    Reflect.defineMetadata(key, metadataValue, PartialClass.prototype);
+  });
+
+  return PartialClass as Constructor<Partial<T>>;
+}
+
+/**
+ * Utility to pick specific properties from a class.
+ */
+export function PickType<T, K extends keyof T>(
+  BaseClass: Constructor<T>,
+  keys: K[],
+): Constructor<Pick<T, K>> {
+  class PickClass {
+    constructor() {
+      (keys as string[]).forEach((key: string) => {
+        Reflect.defineMetadata(
+          "design:type",
+          Reflect.getMetadata("design:type", BaseClass.prototype, key),
+          this,
+          key,
+        );
+      });
+    }
+  }
+
+  Reflect.decorate([Reflect.metadata("design:properties", keys)], PickClass);
+
+  // Copy metadata from BaseClass to PickClass
+  Reflect.getMetadataKeys(BaseClass.prototype).forEach((key) => {
+    Reflect.defineMetadata(
+      key,
+      Reflect.getMetadata(key, BaseClass.prototype),
+      PickClass.prototype,
+    );
+  });
+
+  return PickClass as Constructor<Pick<T, K>>;
+}
+
+/**
+ * Utility to omit specific properties from a class.
+ */
+export function OmitType<T, K extends keyof T>(
+  BaseClass: Constructor<T>,
+  keys: K[],
+): Constructor<Omit<T, K>> {
+  const allKeys = Reflect.getMetadata("design:properties", BaseClass) || [];
+  const omitKeys = new Set(keys);
+  const finalKeys = allKeys.filter((key: string) => !omitKeys.has(key as any));
+
+  class OmitClass {
+    constructor() {
+      finalKeys.forEach((key: string) => {
+        Reflect.defineMetadata(
+          "design:type",
+          Reflect.getMetadata("design:type", BaseClass.prototype, key),
+          this,
+          key,
+        );
+      });
+    }
+  }
+
+  Reflect.decorate(
+    [Reflect.metadata("design:properties", finalKeys)],
+    OmitClass,
+  );
+
+  // Copy metadata from BaseClass to OmitClass
+  Reflect.getMetadataKeys(BaseClass.prototype).forEach((key) => {
+    Reflect.defineMetadata(
+      key,
+      Reflect.getMetadata(key, BaseClass.prototype),
+      OmitClass.prototype,
+    );
+  });
+
+  return OmitClass as Constructor<Omit<T, K>>;
+}

package/src/middleware.ts

@@ -0,0 +1,98 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import { Service } from "typedi";
+import { IRequest, IResponse } from "./icore";
+import { HttpException, UnauthorizedException } from "./exceptions";
+import Container, { AUTHORIZATION_META_KEY } from "./container";
+
+export abstract class AppMiddleware {
+  abstract invoke(req: IRequest, res?: IResponse): Promise<IRequest|HttpException>;
+}
+export type AuthHandler = (req: IRequest, roles?: string[]) => Promise<IRequest | HttpException>;
+
+
+
+export type Constructor<T> = { new(...args: any[]): T };
+
+export abstract class AuthorizeMiddleware {
+  abstract authorize(roles: string[]): (req: IRequest, res?: IResponse) => IRequest | Promise<IRequest>;
+
+}
+
+
+export type AuthReturnTypes = IRequest | Promise<IRequest>
+
+interface AuthorizeClass {
+  authorize(req: IRequest, options?:any): AuthReturnTypes;
+}
+
+export function Authorize(target: { new (...args: any[]): AuthorizeClass }) {
+  if (typeof target.prototype.authorize !== "function") {
+    throw new Error(
+      `Class "${target.name}" must implement an "authorize" method.`,
+    );
+  }
+  Service()(target);
+}
+
+
+// export function Authorized(target: Function): void;
+export function Authorized(): ClassDecorator & MethodDecorator;
+export function Authorized(options?: any): ClassDecorator & MethodDecorator;
+export function Authorized(options: any = {}): MethodDecorator | ClassDecorator {
+  return function (target: any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) {
+    if (propertyKey && descriptor) {
+      Reflect.defineMetadata(AUTHORIZATION_META_KEY, { authorize: true, options}, target.constructor, propertyKey);
+    } else {
+      Reflect.defineMetadata(AUTHORIZATION_META_KEY, { authorize: true, options}, target);
+    }
+  };
+}
+
+
+export function Middleware(target: Constructor<AppMiddleware>) {
+  if (typeof target.prototype.invoke !== "function") {
+    throw new Error(
+      `Class "${target.name}" must implement an "invoke" method.`,
+    );
+  }
+
+  Service()(target);
+}
+
+
+export function UseMiddleware<T extends AppMiddleware | (new (...args: any[]) => AppMiddleware)>(
+  options: T | T[],
+): MethodDecorator & ClassDecorator {
+  return function (
+    target: Object | Function,
+    propertyKey?: string | symbol,
+    descriptor?: PropertyDescriptor,
+  ) {
+    const normalizeMiddleware = (middleware: any) =>
+      typeof middleware === "function" ? new middleware() : middleware;
+    const middlewareList = (Array.isArray(options) ? options : [options]).map(normalizeMiddleware);
+    if (typeof target === "function" && !propertyKey) {
+      const existingMiddlewares =
+        Reflect.getMetadata("controller:middleware", target) || [];
+      Reflect.defineMetadata(
+        "controller:middleware",
+        [...existingMiddlewares, ...middlewareList],
+        target
+      );
+    } else if (descriptor) {
+      const existingMiddlewares =
+        Reflect.getMetadata("route:middleware", target, propertyKey!) || [];
+      Reflect.defineMetadata(
+        "route:middleware",
+        [...existingMiddlewares, ...middlewareList],
+        target,
+        propertyKey!
+      );
+    }
+  };
+}

package/src/multipart.ts

@@ -0,0 +1,116 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+import {
+  MultipartFile as FsM,
+  MultipartValue,
+  SavedMultipartFile,
+} from "@fastify/multipart";
+import { IRequest } from "./icore";
+import fs from "fs";
+import path from "path";
+import { pipeline } from "stream/promises";
+import { InternalErrorException } from "./exceptions";
+import { REQUEST_BODY_FILE_KEY, REQUEST_BODY_FILES_KEY } from "./container";
+
+export function UploadFile(fieldName: string) {
+  return function (
+    target: any,
+    propertyKey: string | symbol,
+    parameterIndex: number
+  ) {
+    if (!Reflect.hasMetadata(REQUEST_BODY_FILE_KEY, target, propertyKey)) {
+      Reflect.defineMetadata(REQUEST_BODY_FILE_KEY, [], target, propertyKey);
+    }
+    const existingMetadata = Reflect.getMetadata(
+      REQUEST_BODY_FILE_KEY,
+      target,
+      propertyKey
+    ) as {
+      fieldName: string;
+      index: number;
+    }[];
+    existingMetadata.push({ fieldName, index: parameterIndex });
+    Reflect.defineMetadata(
+      REQUEST_BODY_FILE_KEY,
+      existingMetadata,
+      target,
+      propertyKey
+    );
+  };
+}
+
+export function UploadFiles(fieldName?: string) {
+  return function (
+    target: any,
+    propertyKey: string | symbol,
+    parameterIndex: number
+  ) {
+    if (!Reflect.hasMetadata(REQUEST_BODY_FILES_KEY, target, propertyKey)) {
+      Reflect.defineMetadata(REQUEST_BODY_FILES_KEY, [], target, propertyKey);
+    }
+    const existingMetadata = Reflect.getMetadata(
+      REQUEST_BODY_FILES_KEY,
+      target,
+      propertyKey
+    ) as {
+      fieldName: string;
+      index: number;
+    }[];
+    existingMetadata.push({
+      fieldName: fieldName ? fieldName : "all",
+      index: parameterIndex,
+    });
+    Reflect.defineMetadata(
+      REQUEST_BODY_FILES_KEY,
+      existingMetadata,
+      target,
+      propertyKey
+    );
+  };
+}
+
+type Foptions = {
+  saveAs?: string;
+  dest?: true;
+};
+
+export type MultipartFile = FsM | SavedMultipartFile;
+export function UploadFileFromRequest(req: IRequest, options?: Foptions) {
+  return Promise.resolve(
+    req.file().then(async (f) => {
+      if (f && f.file) {
+        let fname = f.filename;
+        if (options) {
+          if (options.dest) {
+            fname = options.saveAs
+              ? options.dest + "/" + options.saveAs
+              : options.dest + "/" + f.filename;
+          } else {
+            fname = path.join(
+              process.cwd(),
+              `public/${options.saveAs ? options.saveAs : f.filename}`
+            );
+          }
+        } else {
+          fname = path.join(process.cwd(), `public/${f.filename}`);
+        }
+
+        if (fs.existsSync(fname)) {
+          throw new InternalErrorException("File already exists.");
+        }
+
+        await pipeline(f.file!, fs.createWriteStream(fname));
+
+        return {
+          ...f,
+          filename: options?.saveAs ? options.saveAs : f.filename,
+        } as MultipartFile;
+      }
+    })
+  );
+}