@avleon/core 0.0.28 → 0.0.30

package/src/index.ts

@@ -1,30 +0,0 @@
-/**
- * @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/interfaces/avleon-application.ts

@@ -1,32 +0,0 @@
-interface AvleonApplication {
-  // all use
-  useCors: () => void;
-  /**
-   * function for register database
-   * @param options datasource options. options can be plain object or avleon config class
-   * */
-  useDatasource: () => void;
-  useMultipart: () => void;
-  useOpenApi: () => void;
-  useMiddlewares: () => void;
-  useAuthorization: () => void;
-  useSerialization: () => void;
-  useControllers: () => void;
-  useStaticFiles: () => void;
-  /**
-   * @experimental
-   * use https as defalut http protocol
-   * */
-  useHttps: () => void;
-
-  // all map
-  mapGet: () => void;
-  mapPost: () => void;
-  mapPut: () => void;
-  mapPatch: () => void;
-  mapOptions: () => void;
-  mapGroup: () => void;
-  // all others
-  // run
-  run: () => void;
-}

package/src/logger.ts

@@ -1,72 +0,0 @@
-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

@@ -1,159 +0,0 @@
-/**
- * @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

@@ -1,119 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-import { Service } from "typedi";
-import { IRequest, IResponse } from "./icore";
-import {
-  HttpExceptionTypes as 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

@@ -1,116 +0,0 @@
-/**
- * @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;
-      }
-    }),
-  );
-}