@avleon/core 0.0.26 → 0.0.28

package/src/exceptions/http-exceptions.ts

@@ -1,86 +1,86 @@
-/**
- * @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)
-}
+/**
+ * @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 +1 @@
-export * from './http-exceptions';
+export * from "./http-exceptions";

package/src/exceptions/system-exception.ts

@@ -1,34 +1,35 @@
-/**
- * @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.`)
-    }
-}
+/**
+ * @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 +1,206 @@
-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 });
-    }
-  }
-}
+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 });
+    }
+  }
+}