@avleon/core 0.0.28 → 0.0.30

package/src/controller.ts

@@ -1,125 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import Container, { Service } from "typedi";
-import container, {
-  API_CONTROLLER_METADATA_KEY,
-  CONTROLLER_META_KEY,
-  registerController,
-} from "./container";
-
-/**
- * Options for configuring a controller.
- * @remarks
- * Controller default options
- * @type {Object} ControllerOptions
- * @property {string} [name] - The name of the controller.
- * @property {string} [path] - The base path for the controller's routes.
- * @property {string} [version] - The version of the controller. If not provided, it will default to the version from `package.json`.
- * @property {string} [since] - The date or version since the controller was introduced.
- * @property {any} [meta] - Additional metadata associated with the controller.
- */
-export type ControllerOptions = {
-  /**
-   *@property {string} name
-   *@description Name of the controller. If specified it'll used as  swagger tags
-   *@default Contorller class name
-   * */
-  name?: string;
-  path?: string;
-  version?: string; // Will look at package.json if not set
-  since?: string;
-  meta?: any;
-};
-
-export function createControllerDecorator(
-  type: "api" | "web" = "web",
-): (
-  pathOrOptions?: string | ControllerOptions,
-  maybeOptions?: ControllerOptions,
-) => ClassDecorator {
-  return function (
-    pathOrOptions?: string | ControllerOptions,
-    maybeOptions?: ControllerOptions,
-  ): ClassDecorator {
-    return function (target: Function) {
-      let path = "/";
-      let options: ControllerOptions = {};
-
-      if (typeof pathOrOptions === "string") {
-        path = pathOrOptions;
-        options = maybeOptions || {};
-      } else if (typeof pathOrOptions === "object") {
-        options = pathOrOptions;
-        path = options.path || "/";
-      }
-      Reflect.defineMetadata(API_CONTROLLER_METADATA_KEY, true, target);
-      // Ensure Service is applied as a ClassDecorator
-      if (typeof Service === "function") {
-        registerController(target); // Add to custom registry
-        Service()(target); // Apply DI decorator
-        Reflect.defineMetadata(
-          CONTROLLER_META_KEY,
-          { type, path, options },
-          target,
-        );
-      } else {
-        throw new Error("Service decorator is not a function");
-      }
-    };
-  };
-}
-
-// Predefined Controller Decorators
-//export const Controller = createControllerDecorator("web");
-/**
- *@description Api controller's are used for rest . It will populate
- * json on return and all it http methods {get} {post} etc must return
- *Results.*
- * @param path {string} this will used as route prefix
- *
- **/
-
-export function ApiController(target: Function): void;
-export function ApiController(path: string): ClassDecorator;
-/**
- *@description Api controller's are used for rest . It will populate
- * json on return and all it http methods {get} {post} etc must return
- * Results.*
- * @param {ControllerOptions} options this will used as route prefix
- *
- **/
-export function ApiController(options: ControllerOptions): ClassDecorator;
-export function ApiController(
-  path: string,
-  options?: ControllerOptions,
-): ClassDecorator;
-export function ApiController(
-  pathOrOptions: Function | string | ControllerOptions = "/",
-  mayBeOptions?: ControllerOptions,
-): any {
-  if (typeof pathOrOptions == "function") {
-    Reflect.defineMetadata(API_CONTROLLER_METADATA_KEY, true, pathOrOptions);
-    // Ensure Service is applied as a ClassDecorator
-    if (typeof Service === "function") {
-      registerController(pathOrOptions); // Add to custom registry
-      Service()(pathOrOptions); // Apply DI decorator
-      Reflect.defineMetadata(
-        CONTROLLER_META_KEY,
-        { type: "api", path: "/", options: {} },
-        pathOrOptions,
-      );
-    } else {
-      throw new Error("Service decorator is not a function");
-    }
-  } else {
-    if (mayBeOptions) {
-      return createControllerDecorator("api")(pathOrOptions, mayBeOptions);
-    }
-    return createControllerDecorator("api")(pathOrOptions);
-  }
-}

package/src/decorators.ts

@@ -1,27 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import { Service as _service } from "typedi";
-import container, { registerService } from "./container";
-export function AppService(target: any): void;
-export function AppService(): any;
-export function AppService(target?: any) {
-  if (target) {
-    _service()(target);
-  } else {
-    return function (tg: any) {
-      _service()(tg);
-    };
-  }
-}
-
-export * from "./controller";
-export * from "./route-methods";
-export * from "./openapi";
-export const Utility = _service;
-export const Helper = _service;
-export * from "./params";

package/src/environment-variables.ts

@@ -1,53 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-
-import dotenv from "dotenv";
-import path from "path";
-import fs, { existsSync } from "fs";
-import { Service } from "typedi";
-import {
-  EnvironmentVariableNotFound,
-  SystemUseError,
-} from "./exceptions/system-exception";
-
-dotenv.config({ path: path.join(process.cwd(), ".env") });
-
-@Service()
-export class Environment {
-  private parseEnvFile(filePath: string): any {
-    try {
-      const isExis = existsSync(filePath);
-      if (!isExis) {
-        return { ...process.env };
-      }
-      const fileContent = fs.readFileSync(filePath, "utf8");
-      const parsedEnv = dotenv.parse(fileContent);
-      return { ...parsedEnv, ...process.env };
-    } catch (error) {
-      console.error(`Error parsing .env file: ${error}`);
-      return {};
-    }
-  }
-
-  get<T = any>(key: string): T {
-    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), ".env"));
-    return parsedEnv[key] as T;
-  }
-
-  getOrThrow<T = any>(key: string): T {
-    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), ".env"));
-    if (!Object(parsedEnv).hasOwnProperty(key)) {
-      throw new EnvironmentVariableNotFound(key);
-    }
-    return parsedEnv[key] as T;
-  }
-
-  getAll<T = any>(): T {
-    const parsedEnv = this.parseEnvFile(path.join(process.cwd(), ".env"));
-    return parsedEnv as T;
-  }
-}

package/src/exceptions/http-exceptions.ts

@@ -1,86 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export abstract class BaseHttpException extends Error {
-  code: number = 500;
-  name: string = "HttpException";
-  constructor(message: any) {
-    super(JSON.stringify(message));
-  }
-  isCustomException() {
-    return true;
-  }
-}
-
-export class BadRequestException extends BaseHttpException {
-  name: string = "BadRequest";
-  code: number = 400;
-
-  constructor(message: any) {
-    super(message);
-  }
-}
-
-export class ValidationErrorException extends BadRequestException {
-  name: string = "ValidationError";
-}
-
-export class InternalErrorException extends BaseHttpException {
-  name: string = "InternalError";
-  code: number = 500;
-
-  constructor(message: any = "Something going wrong") {
-    super(message);
-  }
-}
-
-export class NotFoundException extends BaseHttpException {
-  name: string = "NotFound";
-  code: number = 404;
-  constructor(message: any) {
-    super(message);
-  }
-}
-
-export class UnauthorizedException extends BaseHttpException {
-  name: string = "Unauthorized";
-  code: number = 401;
-  constructor(message: any) {
-    super(message);
-  }
-}
-
-export class ForbiddenException extends BaseHttpException {
-  name: string = "Forbidden";
-  code: number = 403;
-  constructor(message: any) {
-    super(message);
-  }
-}
-
-export type HttpExceptionTypes =
-  | NotFoundException
-  | BadRequestException
-  | UnauthorizedException
-  | InternalErrorException
-  | ForbiddenException;
-
-// export type HttpExceptions = {
-//   NotFound: (message: any) => NotFoundException,
-//   ValidationError: (message: any) =>ValidationErrorException,
-//   BadRequest: (message: any) => BadRequestException,
-//   Unauthorized: (message: any) => UnauthorizedException,
-//   Forbidden: (message: any) => ForbiddenException,
-//   InternalError: (message: any) => InternalErrorException
-// }
-export const HttpExceptions = {
-  notFound: (message: any = "") => new NotFoundException(message),
-  validationError: (message: any = "") => new ValidationErrorException(message),
-  badRequest: (message: any = "") => new BadRequestException(message),
-  unauthorized: (message: any = "") => new UnauthorizedException(message),
-  forbidden: (message: any = "") => new ForbiddenException(message),
-  internalError: (message: any = "") => new InternalErrorException(message),
-};

package/src/exceptions/index.ts

@@ -1 +0,0 @@
-export * from "./http-exceptions";

package/src/exceptions/system-exception.ts

@@ -1,35 +0,0 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-export interface IRouteDuplicateErr {
-  path: string;
-  mpath: string;
-  method: string;
-  controller: string;
-  inverseController?: string;
-}
-
-export class SystemUseError extends Error {
-  constructor(message: string) {
-    super(message);
-  }
-}
-export class DuplicateRouteException extends Error {
-  constructor(params: IRouteDuplicateErr) {
-    let sameController = params.controller == params.inverseController;
-    let message = `Duplicate route found for method ${params.method.toUpperCase()}:${params.path == "" ? "'/'" : params.path} `;
-    message += sameController
-      ? `in ${params.controller}`
-      : `both in ${params.controller} and ${params.inverseController}`;
-    super(message);
-  }
-}
-
-export class EnvironmentVariableNotFound extends Error {
-  constructor(key: string) {
-    super(`${key} not found in environment variables.`);
-  }
-}

package/src/file-storage.ts

@@ -1,206 +0,0 @@
-import fs, { createReadStream, PathLike } from "fs";
-import path from "path";
-import { pipeline } from "stream/promises";
-import {
-  BadRequestException,
-  InternalErrorException,
-} from "./exceptions/http-exceptions";
-import { MultipartFile } from "./multipart";
-import { AppService } from "./decorators";
-import os from "os";
-import { SystemUseError } from "./exceptions/system-exception";
-import { SavedMultipartFile } from "@fastify/multipart";
-
-interface TransformOptions {
-  resize?: { width: number; height: number };
-  format?: "jpeg" | "png" | "webp" | "avif";
-  quality?: number;
-  // Add other sharp options as needed
-}
-
-/* 
-//temp file
-  files[0].type // "file"
-  files[0].filepath
-  files[0].fieldname
-  files[0].filename
-  files[0].encoding
-  files[0].mimetype
-  files[0].fields 
-
-*/
-
-/* 
-// stream file
-  data.file // stream
-  data.fields // other parsed parts
-  data.fieldname
-  data.filename
-  data.encoding
-  data.mimetype
-*/
-
-export interface FileStorageInterface {
-  transform(options: TransformOptions): FileStorage;
-  save(
-    file: MultipartFile,
-    options?: SaveOptionsSingle,
-  ): Promise<MultipartFile | undefined>;
-  saveAll(
-    files: MultipartFile[],
-    options?: SaveOptions,
-  ): Promise<MultipartFile[] | undefined>;
-
-  remove(filepath: PathLike): Promise<void>;
-}
-
-export interface SaveOptions {
-  overwrite?: boolean;
-  to?: string;
-}
-
-export interface SaveOptionsSingle extends SaveOptions {
-  saveAs?: string;
-}
-
-@AppService
-export class FileStorage implements FileStorageInterface {
-  private transformOptions: TransformOptions | null = null;
-
-  transform(options: TransformOptions) {
-    this.transformOptions = options;
-    return this;
-  }
-
-  private isFileExists(fpath: PathLike) {
-    return fs.existsSync(fpath);
-  }
-
-  async save(f: MultipartFile, options?: SaveOptionsSingle) {
-    let foptions: SaveOptionsSingle = {
-      overwrite: options && options.overwrite ? options.overwrite : true,
-    };
-    try {
-      if (f.type == "file") {
-        const fname = path.join(process.cwd(), `public/${f.filename}`);
-
-        if (!foptions.overwrite && this.isFileExists(fname)) {
-          throw new SystemUseError("File already exits.");
-        }
-
-        await pipeline(f.file, fs.createWriteStream(fname));
-        return f;
-      }
-    } catch (err) {
-      throw new SystemUseError("Can't upload file");
-    }
-  }
-
-  async remove(filepath: PathLike) {
-    if (!this.isFileExists(path.join(process.cwd(), "public/" + filepath))) {
-      throw new SystemUseError("File doesn't exists.");
-    }
-    return fs.unlinkSync(path.join(process.cwd(), "public/" + filepath));
-  }
-
-  async saveAll(files: MultipartFile[], options?: SaveOptions) {
-    try {
-      let foptions: SaveOptions = {
-        overwrite: options && options.overwrite ? options.overwrite : true,
-      };
-      for (let f of files) {
-        let uploadPath = "public";
-        if (options?.to) {
-          uploadPath = `public/${options.to}`;
-        }
-        const fname = path.join(process.cwd(), `${uploadPath}/${f.filename}`);
-        await this.ensureDirectoryExists(fname);
-        if (f.file) {
-          await pipeline(f.file, fs.createWriteStream(fname));
-        } else {
-          const fp = f as SavedMultipartFile;
-          await pipeline(
-            fs.createReadStream(fp.filepath),
-            fs.createWriteStream(fname),
-          );
-          fs.unlinkSync(fp.filepath);
-        }
-      }
-      return files;
-    } catch (error) {
-      console.error(error);
-      throw new SystemUseError("Can't upload file");
-    }
-  }
-
-  private async processImage(
-    fileStream: NodeJS.ReadableStream,
-    outputPath: string,
-  ) {
-    try {
-      const sharp = await import("sharp"); // Lazy import sharp
-
-      let sharpPipeline = sharp.default();
-
-      if (this.transformOptions?.resize) {
-        sharpPipeline = sharpPipeline.resize(
-          this.transformOptions.resize.width,
-          this.transformOptions.resize.height,
-        );
-      }
-
-      if (this.transformOptions?.format) {
-        switch (this.transformOptions.format) {
-          case "jpeg":
-            sharpPipeline = sharpPipeline.jpeg({
-              quality: this.transformOptions.quality || 80,
-            });
-            break;
-          case "png":
-            sharpPipeline = sharpPipeline.png({
-              quality: this.transformOptions.quality || 80,
-            });
-            break;
-          case "webp":
-            sharpPipeline = sharpPipeline.webp({
-              quality: this.transformOptions.quality || 80,
-            });
-            break;
-          case "avif":
-            sharpPipeline = sharpPipeline.avif({
-              quality: this.transformOptions.quality || 80,
-            });
-            break;
-          default:
-            break;
-        }
-      }
-
-      await pipeline(
-        fileStream,
-        sharpPipeline,
-        fs.createWriteStream(outputPath),
-      );
-    } catch (error: any) {
-      if (
-        error.code === "MODULE_NOT_FOUND" &&
-        error.message.includes("sharp")
-      ) {
-        throw new InternalErrorException(
-          "sharp module not found. Please install sharp to use image transformations.",
-        );
-      }
-      console.error("Image processing failed:", error);
-      throw new InternalErrorException("Image processing failed.");
-    } finally {
-      this.transformOptions = null; // Reset transform options after processing
-    }
-  }
-
-  private async ensureDirectoryExists(filePath: string) {
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-  }
-}