@avleon/core 0.0.19 → 0.0.24

package/src/file-storage.ts

@@ -0,0 +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 });
+    }
+  }
+}

package/src/helpers.ts

@@ -0,0 +1,328 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import { instanceToPlain, plainToInstance } from "class-transformer";
+import { InternalErrorException } from "./exceptions";
+import fs from "fs";
+import container from "./container";
+import { SystemUseError } from "./exceptions/system-exception";
+import crypto, { UUID } from "crypto";
+import { getMetadataStorage, validate, validateSync } from "class-validator";
+
+export const uuid = crypto.randomUUID();
+
+export function inject<T>(cls: new (...args: any[]) => T): T {
+  try {
+    return container.get(cls);
+  } catch (error) {
+    throw new SystemUseError(
+      `Not a project class. Maybe you wanna register it first.`
+    );
+  }
+}
+
+export type Constructor<T = any> = new (...args: any[]) => T;
+
+export function isConstructor(func: any): boolean {
+
+  if (typeof func !== "function") {
+    return false;
+  }
+
+  if (func === Function.prototype.bind || func instanceof RegExp) {
+    return false;
+  }
+
+  if (func.prototype && typeof func.prototype === "object") {
+    return true;
+  }
+
+  try {
+    const instance = new (func as any)();
+    return typeof instance === "object";
+  } catch (e) {
+    return false;
+  }
+}
+
+export function formatUrl(path: string): string {
+  if (typeof path !== "string") {
+    throw new Error("The path must be a string");
+  }
+  path = path.trim();
+
+  if (!path.startsWith("/")) {
+    path = "/" + path;
+  }
+  path = path.replace(/\/\/+/g, "/");
+  if (path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+
+  return path;
+}
+
+export function parsedPath(ipath: string): string {
+  return !ipath.startsWith("/") ? "/" + ipath : ipath;
+}
+export const isClassValidator = (target: Constructor) => {
+  try {
+    const clsval = require("class-validator");
+    const result = getMetadataStorage().getTargetValidationMetadatas(
+      target,
+      "",
+      false,
+      false
+    );
+    return result.length > 0;
+  } catch (err: any) {
+    console.log(err);
+    return false;
+  }
+};
+
+export interface MatchLocation {
+  line: number;
+  column: number;
+}
+export const getLineNumber = (
+  filePath: string,
+  rpath: string | RegExp
+): MatchLocation[] | null => {
+  let numbers = [];
+  try {
+    const fileContent = fs.readFileSync(filePath, "utf8");
+    const lines = fileContent.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const match = lines[i].match(rpath);
+
+      if (match) {
+        console.log(match);
+        numbers.push({
+          line: i + 1,
+          column: match.index ?? 0,
+        });
+      }
+    }
+
+    return numbers;
+  } catch (error) {
+    return numbers;
+  }
+};
+
+export function normalizePath(base: string = "/", subPath: string = "/") {
+  return `/${base}/${subPath}`.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+
+export function extrctParamFromUrl(url: string) {
+  const splitPart = url
+    .split("/")
+    .filter((x) => x.startsWith(":") || x.startsWith("?:"));
+  return splitPart.map((f) => ({
+    key: f.replace(/(\?|:)/g, ""),
+    required: !f.startsWith("?:"),
+  }));
+}
+
+export function findDuplicates(arr: string[]): string[] {
+  const seen = new Set();
+  const duplicates = new Set();
+
+  for (const str of arr) {
+    if (seen.has(str)) {
+      duplicates.add(str);
+    } else {
+      seen.add(str);
+    }
+  }
+
+  return Array.from(duplicates) as string[];
+}
+
+export function getDataType(expectedType: any) {
+  switch (expectedType.name) {
+    case "Object":
+      if (Array.isArray(expectedType)) {
+        return "array";
+      }
+      return "object";
+    case "String":
+      return "string";
+    case "Number":
+      return "number";
+    case "Boolean":
+      return "boolean";
+    default:
+      return expectedType;
+  }
+}
+export function isValidType(value: any, expectedType: any): boolean {
+  if (value === undefined || value === null) return true;
+
+  switch (expectedType.name) {
+    case "String":
+      return typeof value === "string";
+    case "Number":
+      return typeof value === "number" || !isNaN(Number(value));
+    case "Boolean":
+      return typeof value === "boolean";
+    default:
+      return value instanceof expectedType;
+  }
+}
+
+export function isValidJsonString(value: string): object | boolean {
+  try {
+    return JSON.parse(value);
+  } catch (err: any) {
+    return false;
+  }
+}
+
+export function jsonToJs(value: string) {
+  try {
+    return JSON.parse(value);
+  } catch (err: any) {
+    return false;
+  }
+}
+
+export function jsonToInstance(value: string, instance: Constructor) {
+  try {
+    const parsedValue = JSON.parse(value);
+    return plainToInstance(instance, parsedValue);
+  } catch (err: any) {
+    return false;
+  }
+}
+
+export function transformObjectByInstanceToObject(
+  instance: Constructor,
+  value: object
+) {
+  return instanceToPlain(plainToInstance(instance, value), {
+    excludeExtraneousValues: true,
+    exposeUnsetFields: true,
+  });
+}
+
+export const isClassValidatorClass = (target: Constructor) => {
+  try {
+    const clsval = require("class-validator");
+    const result = clsval
+      .getMetadataStorage()
+      .getTargetValidationMetadatas(target, undefined, false, false);
+    return result.length > 0;
+  } catch (err: any) {
+    return false;
+  }
+};
+
+export async function validateObjectByInstance(
+  target: Constructor,
+  value: object = {},
+  options: "object" | "array" = "array"
+) {
+  try {
+    const { validateOrReject } = require("class-validator");
+    const { plainToInstance } = require("class-transformer");
+    await validateOrReject(plainToInstance(target, value));
+  } catch (error: any) {
+    if (typeof error == "object" && Array.isArray(error)) {
+      const errors =
+        options == "object"
+          ? error.reduce((acc: any, x: any) => {
+              //acc[x.property] = Object.values(x.constraints);
+              acc[x.property] = x.constraints;
+              return acc;
+            }, {})
+          : error.map((x) => ({
+              path: x.property,
+              constraints: x.constraints,
+            }));
+      return errors;
+    } else {
+      throw new InternalErrorException("Can't validate object");
+    }
+  }
+}
+
+type ValidationError = {
+  count: number;
+  errors: any;
+};
+
+export function validateRequestBody(
+  target: Constructor,
+  value: object,
+  options: "object" | "array" = "array"
+): ValidationError {
+  if (!isClassValidatorClass(target)) return { count: 0, errors: {} };
+  const error = validateSync(plainToInstance(target, value ? value : {}));
+  const errors =
+    options == "object"
+      ? error.reduce((acc: any, x: any) => {
+          //acc[x.property] = Object.values(x.constraints);
+          acc[x.property] = x.constraints;
+          return acc;
+        }, {})
+      : error.map((x) => ({ path: x.property, constraints: x.constraints }));
+  return { count: error.length, errors } as ValidationError;
+}
+
+export function pick<T extends object>(obj: T, paths: string[]): Partial<T> {
+  const result: any = {};
+
+  for (const path of paths) {
+    const keys = path.split(".");
+    let source: any = obj;
+    let target: any = result;
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+
+      if (!(key in source)) break;
+
+      if (i === keys.length - 1) {
+        target[key] = source[key];
+      } else {
+        source = source[key];
+        target[key] = target[key] || {};
+        target = target[key];
+      }
+    }
+  }
+
+  return result;
+}
+
+
+export function exclude<T extends object>(
+  obj: T | T[],
+  paths: string[],
+): Partial<T> | Partial<T>[] {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => exclude(item, paths) as Partial<T>);
+  }
+
+  const clone = structuredClone(obj); // Or use lodash.cloneDeep
+  for (const path of paths) {
+    const keys = path.split(".");
+    let target: any = clone;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!(keys[i] in target)) break;
+      target = target[keys[i]];
+    }
+
+    delete target?.[keys[keys.length - 1]];
+  }
+
+  return clone;
+}
+
+