fiberx-backend-toolkit 0.0.1 → 0.0.7

package/dist/chunk-BK6YPN2O.js

@@ -0,0 +1,1029 @@
+// src/utils/logger_util.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/config/constants.ts
+import path from "path";
+var BASE_DIR = process.cwd();
+var LOG_DIR = path.join(BASE_DIR, "logs");
+var ENV_VAR_DIR = path.join(BASE_DIR, "environment_varaiables");
+var SCHEMAS_DIR = path.join(BASE_DIR, "src/database/schemas");
+var SCHEMA_SNAPSHOTS_DIR = path.join(BASE_DIR, "src/database/schema_snapshots");
+var MODELS_DIR = path.join(BASE_DIR, "src/database/models");
+var MIGRATIONS_DIR = path.join(BASE_DIR, "src/database/migrations");
+var SEEDERS_DIR = path.join(BASE_DIR, "src/database/seeders");
+var SEQUELIZE_META_TABLE_NAME = "sequelize_database_tables_meta";
+var SEQUELIZE_SEEDER_META_TABLE_NAME = "sequelize_database_table_seeder_meta";
+var REQUEST_ID_COOKIE_MAX_AGE = 1e3 * 60 * 60 * 24 * 7;
+var CORS_MAX_AGE_IN_MICRO_SECONDS = 1e3 * 60 * 10;
+var REQUEST_RATE_LIMITTER_OPTIONS = {
+  window_ms: 60 * 1e3,
+  // 1 MINS
+  max_requests: 50,
+  message: "\u23F3 Too many requests from this IP, please try again later"
+};
+
+// src/utils/logger_util.ts
+var LoggerUtil = class {
+  module_name;
+  base_dir;
+  log_file_path;
+  log_directory;
+  store_log_locally;
+  constructor(module_name) {
+    this.module_name = module_name;
+    this.store_log_locally = true;
+    this.base_dir = process.cwd();
+    this.log_directory = this.ensureDirExists(LOG_DIR);
+    this.log_file_path = this.getLogFilePath();
+  }
+  /**
+   * Ensures a directory exists. If it doesn't, creates it.
+   * @param directory_path - Path to the directory
+   * @returns The absolute path of the ensured directory
+  */
+  ensureDirExists(directory_path) {
+    const resolved_path = path2.resolve(directory_path);
+    if (!fs.existsSync(resolved_path)) {
+      fs.mkdirSync(resolved_path, { recursive: true });
+    }
+    return resolved_path;
+  }
+  /**
+   * Generate log unique log file name with timestamp and module name
+   * @returns The absolute path of the module log file
+  */
+  getLogFilePath() {
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const file_name = `${this.module_name}-${timestamp}.log`;
+    const log_file_path = path2.join(this.log_directory, file_name);
+    return log_file_path;
+  }
+  // Safely stringify objects while avoiding circular references
+  safeStringify(obj, space = 2) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(
+      obj,
+      (key, value) => {
+        if (typeof value === "object" && value !== null) {
+          if (seen.has(value)) {
+            return "[Circular]";
+          }
+          seen.add(value);
+        }
+        return value;
+      },
+      space
+    );
+  }
+  // Log a message with optional error data and level
+  log(message = "", data_error = {}, status = "INFO") {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const error_str = data_error && typeof data_error === "object" && Object.keys(data_error).length ? this.safeStringify(data_error, 0) : "";
+    const formatted_message = message.startsWith(`[${this.module_name}]`) ? message : `[${this.module_name}] ${message}`;
+    const log_line = `${timestamp} [${status}] ${formatted_message} ${error_str}
+`;
+    const log_entry = { timestamp, status, message, data_error };
+    if (this.store_log_locally) {
+      fs.appendFileSync(this.log_file_path, log_line);
+    }
+    console.log(`
+${timestamp} [${status}] ${formatted_message}
+`);
+    if (data_error && typeof data_error === "object" && Object.keys(data_error).length) {
+      console.log({ ...data_error });
+      console.log("\n");
+      console.log("========================================");
+    }
+    return log_entry;
+  }
+  // Log info-level messages
+  info(message, data = "") {
+    return this.log(message, data, "INFO");
+  }
+  // Log error-level messages
+  error(message, error = "") {
+    return this.log(message, error, "ERROR");
+  }
+  // Log alert-level messages
+  alert(message, data = "") {
+    return this.log(message, data, "ALERT");
+  }
+  // Log success-level messages
+  success(message, data = "") {
+    return this.log(message, data, "SUCCESS");
+  }
+  // Log how long a method took to execute
+  logExecutionTime(start_time, class_name, method_name) {
+    const [seconds, nanoseconds] = process.hrtime(start_time);
+    const duration_ms = (seconds * 1e3 + nanoseconds / 1e6).toFixed(2);
+    this.info(`${class_name} - ${method_name} completed in ${duration_ms}ms`);
+  }
+};
+var logger_util_default = LoggerUtil;
+
+// src/utils/input_transformer_util.ts
+import axios from "axios";
+import bcrypt from "bcrypt";
+import dayjs from "dayjs";
+var InputTransformerUtil = class {
+  /**
+   * Lookup table for number formatting suffixes
+   */
+  static count_lookup = [
+    { value: 1, symbol: "" },
+    { value: 1e3, symbol: "K" },
+    { value: 1e6, symbol: "M" },
+    { value: 1e9, symbol: "B" },
+    { value: 1e12, symbol: "T" }
+  ];
+  /**
+   * Capitalize the first letter of a string
+   */
+  static capitalize(input) {
+    return input ? input.charAt(0).toUpperCase() + input.slice(1).toLowerCase() : input;
+  }
+  /**
+   * Capitalize the first letter of each word in a string
+   */
+  static capitalizeEachWord(input) {
+    if (!input) {
+      return "";
+    }
+    return input.split(" ").map((word) => this.capitalize(word)).join(" ");
+  }
+  /**
+   * Format date of birth to YYYY-MM-DD
+   */
+  static formatDob(dob) {
+    return dob ? dayjs(dob).format("YYYY-MM-DD") : null;
+  }
+  /**
+   * Format full name from first and last name
+   */
+  static formatMemberFullName(first_name, last_name) {
+    return first_name && last_name ? `${first_name} ${last_name}` : null;
+  }
+  /**
+   * Format member preview string
+   */
+  static formatMemberPreview(first_name, last_name, public_id) {
+    return first_name && last_name && public_id ? `(${public_id}) - ${first_name} ${last_name}` : null;
+  }
+  /**
+   * Format a number with commas
+   */
+  static formatAmount(amount) {
+    if (!amount) {
+      return "0";
+    }
+    return amount > 0 ? Intl.NumberFormat("en-US").format(amount) : amount.toString();
+  }
+  /**
+   * Format large numbers with suffixes (K, M, B, T)
+   */
+  static nFormatter(num, digits = 1) {
+    const lookup_item = this.count_lookup.slice().reverse().find((item) => num >= item.value);
+    if (!lookup_item) {
+      return "0";
+    }
+    const formatted_value = (num / lookup_item.value).toFixed(digits).replace(/\.0+$|(\.[0-9]*[1-9])0+$/, "$1");
+    return `${formatted_value}${lookup_item.symbol}`;
+  }
+  /**
+   * Round a number to two decimal places
+   */
+  static roundToTwoDecimalPlaces(value) {
+    if (typeof value !== "number") {
+      throw new Error("Input must be a number");
+    }
+    return Math.round(value * 100) / 100;
+  }
+  /**
+   * Remove leading zeros from a number or string
+   */
+  static removeLeadingZeros(value) {
+    return value.toString().replace(/^0+/, "") || "0";
+  }
+  /**
+   * Get country/location based on IP address
+   */
+  static async ipAddressToLocation(ip_address = null) {
+    try {
+      const suffix = !ip_address || ip_address === "::1" ? "s" : `?ip=${ip_address}`;
+      const response = await axios.get(`https://ip2c.org/${suffix}`);
+      const response_text = response.data.toString();
+      if (response_text[0] === "1") {
+        const location_parts = response_text.split(";");
+        return location_parts[location_parts.length - 1];
+      }
+      return "Unknown";
+    } catch (error) {
+      console.error(
+        `Error fetching location for IP ${ip_address}:`,
+        error
+      );
+      return "Unknown";
+    }
+  }
+  /**
+   * Convert date of birth string to age
+   */
+  static dobToAge(dob_string) {
+    const dob_date = new Date(dob_string);
+    const today = /* @__PURE__ */ new Date();
+    let age = today.getFullYear() - dob_date.getFullYear();
+    const month_difference = today.getMonth() - dob_date.getMonth();
+    if (month_difference < 0 || month_difference === 0 && today.getDate() < dob_date.getDate()) {
+      age--;
+    }
+    return age;
+  }
+  /**
+   * Hash plain text password
+   */
+  static textToPasswordHash(password) {
+    return bcrypt.hashSync(password, bcrypt.genSaltSync(10));
+  }
+  /**
+  * Ensures singular, snake_case, and appends `_schema`
+  * Example:
+  *  - "Users" → "user_schema"
+  *  - "UserProfile" → "user_profile_schema"
+  */
+  static toSchemaFileName(input) {
+    const snake = this.toSnakeCase(input);
+    const singular = snake.endsWith("s") ? snake.slice(0, -1) : snake;
+    return `${singular}_schema`;
+  }
+  /**
+   * Convert snake_case to Title Case
+   */
+  static toTitleCase(input) {
+    return input.split("_").map(
+      (word) => word.charAt(0).toUpperCase() + word.slice(1)
+    ).join(" ");
+  }
+  /**
+   * Convert snake_case to PascalCase
+   */
+  static toPascalCase(input) {
+    return input.split("_").map(
+      (word) => word.charAt(0).toUpperCase() + word.slice(1)
+    ).join("");
+  }
+  /**
+   * Convert string to snake_case
+   */
+  static toSnakeCase(input) {
+    return input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+  }
+  /**
+   * Pluralize a snake_case string
+   */
+  static pluralizeSnakeCase(snake_str) {
+    const parts = snake_str.split("_");
+    const last_word = parts.pop();
+    let plural_word;
+    if (last_word.endsWith("y") && !/[aeiou]y$/.test(last_word)) {
+      plural_word = last_word.slice(0, -1) + "ies";
+    } else if (["s", "x", "z"].includes(last_word.slice(-1)) || last_word.endsWith("ch") || last_word.endsWith("sh")) {
+      plural_word = `${last_word}es`;
+    } else {
+      plural_word = `${last_word}s`;
+    }
+    return [...parts, plural_word].join("_");
+  }
+  /**
+   * Remove empty, null, or undefined fields from an object
+   */
+  static filterOutEmptyFields(obj) {
+    const filtered_object = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (value !== null && value !== void 0 && !(typeof value === "string" && value.trim() === "") && !(Array.isArray(value) && value.length === 0)) {
+        filtered_object[key] = value;
+      }
+    }
+    return filtered_object;
+  }
+  /**
+   * Safely parse JSON input
+   */
+  static toJson(json_input) {
+    try {
+      if (!json_input) {
+        return null;
+      }
+      if (typeof json_input === "string") {
+        return JSON.parse(json_input);
+      }
+      if (typeof json_input === "object") {
+        return json_input;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Calculate pagination offset and limit
+   */
+  static calculatePaginationOffset(page, size) {
+    const page_number = page > 0 ? page - 1 : 0;
+    const adjusted_size = size > 200 ? 200 : size;
+    const limit = adjusted_size || 10;
+    const offset = page_number * limit;
+    return { limit, offset };
+  }
+  /**
+   * Format paginated response
+   */
+  static formatPaginatedResponse(page, limit, data) {
+    const { count: total_items, rows: records } = data;
+    const current_page = page || 0;
+    const total_pages = Math.ceil(total_items / limit);
+    return {
+      total_items,
+      records,
+      total_pages,
+      current_page
+    };
+  }
+  /**
+   * Compare two records and detect changes
+   */
+  static detectChanges(old_record = {}, new_record = {}, keys_to_check) {
+    const structured_diff = {};
+    const all_keys = keys_to_check ?? Object.keys(new_record);
+    for (const key of all_keys) {
+      const old_value = old_record[key];
+      const new_value = new_record[key];
+      if (old_value == new_value) {
+        continue;
+      }
+      const formatted_old = typeof old_value === "object" && old_value !== null ? JSON.stringify(old_value) : String(old_value ?? "null");
+      const formatted_new = typeof new_value === "object" && new_value !== null ? JSON.stringify(new_value) : String(new_value ?? "null");
+      structured_diff[key] = {
+        old: formatted_old,
+        new: formatted_new
+      };
+    }
+    const readable_changes = Object.entries(
+      structured_diff
+    ).map(
+      ([key, value]) => `${key} changed from '${value.old}' \u2192 '${value.new}'`
+    ).join("; ");
+    return {
+      readable: readable_changes || "No significant changes detected",
+      structured: structured_diff
+    };
+  }
+  /**
+   * Normalize social links object keys
+   */
+  static formatLinksObject(links) {
+    const formatted_links = {};
+    for (const [key, value] of Object.entries(links)) {
+      const normalized_key = key.toLowerCase().endsWith("_link") ? key.toLowerCase() : `${key.toLowerCase()}_link`;
+      formatted_links[normalized_key] = value;
+    }
+    return formatted_links;
+  }
+};
+var input_transformer_util_default = InputTransformerUtil;
+
+// src/utils/input_validator_util.ts
+import fs3 from "fs";
+import dayjs2 from "dayjs";
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter";
+import bcrypt2 from "bcrypt";
+import axios3 from "axios";
+
+// src/utils/env_manager_util.ts
+import fs2 from "fs";
+import path3 from "path";
+import yaml from "js-yaml";
+import axios2 from "axios";
+var EnvManagerUtil = class _EnvManagerUtil {
+  name = "env_manager_util";
+  env_file_name = "env.yaml";
+  static instance;
+  yaml_env_file_path;
+  logger;
+  env_data;
+  // 🔒 Private constructor
+  constructor() {
+    this.env_file_name = this.getEnvFileName();
+    this.yaml_env_file_path = path3.join(ENV_VAR_DIR, this.env_file_name);
+    this.logger = new logger_util_default(this.name);
+    this.env_data = this.readENVData();
+  }
+  // Method to get env file name
+  getEnvFileName() {
+    if (process?.env?.MODE === "development") {
+      return "env.yaml";
+    } else if (process?.env?.MODE === "staging") {
+      return "staging_env.yaml";
+    } else if (process?.env?.MODE === "production") {
+      return "production_env.yaml";
+    } else {
+      return "env.yaml";
+    }
+  }
+  // ✅ Global access point
+  static getInstance() {
+    if (!_EnvManagerUtil.instance) {
+      _EnvManagerUtil.instance = new _EnvManagerUtil();
+    }
+    return _EnvManagerUtil.instance;
+  }
+  // Read environment data from YAML
+  readENVData() {
+    try {
+      if (!fs2.existsSync(this.yaml_env_file_path)) {
+        this.logger.info(`YAML file not found at: ${this.yaml_env_file_path}`);
+        return {};
+      }
+      const file_content = fs2.readFileSync(this.yaml_env_file_path, "utf8");
+      return yaml.load(file_content) || {};
+    } catch (error) {
+      this.logger.error(`${this.name} - readENVData`, { error });
+      return {};
+    }
+  }
+  // Get env var from YAML → process.env → default 
+  getEnvVar(key, default_value) {
+    if (key in this.env_data) {
+      return this.env_data[key];
+    }
+    if (key in process.env) {
+      return process.env[key];
+    }
+    return default_value;
+  }
+  // Fetch remote env variables and merge
+  async fetchRemoteEnv(url) {
+    try {
+      const response = await axios2.get(url);
+      if (typeof response.data === "object" && response.data !== null) {
+        this.env_data = { ...this.env_data, ...response.data };
+        this.logger.success("Remote env variables loaded.");
+      } else {
+        this.logger.error("Unexpected response format from remote env endpoint.");
+      }
+    } catch (error) {
+      this.logger.error(`${this.name} - fetchRemoteEnv`, { error });
+    }
+  }
+};
+var env_manager_util_default = EnvManagerUtil;
+
+// src/utils/input_validator_util.ts
+dayjs2.extend(isSameOrAfter);
+var InputValidatorUtil = class _InputValidatorUtil {
+  static optional_field_regex = /^[a-zA-Z0-9_\-]+$/;
+  static name_regex_reg_exp = /^[A-Za-z.'\s/_-]*$/;
+  static namey_regex_reg_exp = /^[A-Za-z0-9.'\s,/_\-()&]*$/;
+  static email_regex_reg_exp = /^(?=.{1,255}$)[a-zA-Z0-9._%+-]{1,64}@[a-zA-Z0-9.-]{1,190}\.[a-zA-Z]{2,}$/i;
+  static tel_regex_reg_exp = /^[\s()+-]*([0-9][\s()+-]*){6,20}$/;
+  static pass_regex_reg_exp = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{6,}$/;
+  static url_regex_reg_exp = /^(https?:\/\/)?((localhost|[a-zA-Z0-9-_.]+)(:[0-9]{1,5})?)(\/[a-zA-Z0-9-._~:/?#@!$&'()*+,;=%]*)?$/;
+  static text_area_regex_reg_exp = /^(?=.*[a-zA-Z])[\p{L}\p{N}\p{P}\p{Zs}–—“”‘’]*$/u;
+  static uuid_regex_reg_exp = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  static custom_uuid_regex_reg_exp = /^[A-Z0-9]{12}-[A-Z0-9]{12}-[A-Z0-9]{12}-[A-Z0-9]{12}$/;
+  static env_manager = env_manager_util_default.getInstance();
+  static isValidateIn = (value, allowed) => allowed.includes(value);
+  /** ✅ Check member roles */
+  static isAdmin(name) {
+    return ["SuperAdmin", "AdminI", "AdminT"].includes(name);
+  }
+  static isSuperAdmin(name) {
+    return name === "SuperAdmin";
+  }
+  static isLowerSnakeCase(str) {
+    return /^[a-z]+(_[a-z]+)*$/.test(str);
+  }
+  static isUpperPascalCase(str) {
+    return /^[A-Z][a-zA-Z]*$/.test(str);
+  }
+  static isEmpty(input) {
+    return !input || input.toString().trim() === "";
+  }
+  static isValidOptionalField(str) {
+    return this.optional_field_regex.test(str);
+  }
+  static isValidName(name) {
+    return this.name_regex_reg_exp.test(name);
+  }
+  static isValidNamey(name) {
+    return this.namey_regex_reg_exp.test(name);
+  }
+  static isValidEmail(email) {
+    return this.email_regex_reg_exp.test(email) && email.length <= 254;
+  }
+  static isValidPhoneNumber(tel) {
+    return this.tel_regex_reg_exp.test(tel);
+  }
+  static isValidPassword(password) {
+    return this.pass_regex_reg_exp.test(password);
+  }
+  static isDigit(input) {
+    return !isNaN(input);
+  }
+  static isValidInteger(input) {
+    return Number.isInteger(input) && input > 0;
+  }
+  static isValidFloat(input) {
+    return !isNaN(input) && parseFloat(input) > 0;
+  }
+  static isValidURLY(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+  static isValidURL(url) {
+    return this.url_regex_reg_exp.test(url) && this.isValidURLY(url);
+  }
+  static isBoolean(value) {
+    return typeof value === "boolean" || ["1", "0"].includes(String(value));
+  }
+  static isValidLongText(text) {
+    if (!text || typeof text !== "string") {
+      return false;
+    }
+    const forbidden_pattern = /[<>{};`]/;
+    if (forbidden_pattern.test(text)) {
+      return false;
+    }
+    return this.text_area_regex_reg_exp.test(text.trim());
+  }
+  static isValidUUID(uuid) {
+    return this.uuid_regex_reg_exp.test(uuid);
+  }
+  static isValidCustomUUID(uuid) {
+    return this.custom_uuid_regex_reg_exp.test(uuid);
+  }
+  static isArrayUnique(arr) {
+    return new Set(arr).size === arr.length;
+  }
+  static isValidFutureDate(date_string) {
+    const date = dayjs2(date_string);
+    return date.isValid() && date.isAfter(dayjs2());
+  }
+  static isValidDateAndDifference(input, unit = "years") {
+    if (!input) {
+      return null;
+    }
+    const date = dayjs2(input);
+    if (!date.isValid()) {
+      return null;
+    }
+    return { date, difference: dayjs2().diff(date, unit) };
+  }
+  /** ✅ Validate password hash */
+  static async isValidHashPassword(password, hash_password) {
+    if (!password || !hash_password) {
+      return false;
+    }
+    return await bcrypt2.compare(password, hash_password);
+  }
+  /** ✅ Check environment */
+  static isProduction() {
+    return _InputValidatorUtil?.env_manager?.env_data?.MODE === "production";
+  }
+  static isStaging() {
+    return _InputValidatorUtil?.env_manager?.env_data?.MODE === "staging";
+  }
+  static isDevelopment() {
+    return _InputValidatorUtil?.env_manager?.env_data?.MODE === "development";
+  }
+  /** ✅ Validate ReCaptcha */
+  static async isValidReCaptcha(recpatcha_token) {
+    const {
+      RECAPTCHA_SECRET_KEY,
+      RECPATHA_VERIFY_URL
+    } = _InputValidatorUtil?.env_manager?.env_data;
+    try {
+      const secret_key = RECAPTCHA_SECRET_KEY;
+      const url = RECPATHA_VERIFY_URL;
+      const params = { secret: secret_key, response: recpatcha_token };
+      const response = await axios3.post(url, null, { params });
+      return response.data.success;
+    } catch (error) {
+      console.error("reCAPTCHA verification failed:", error);
+      return false;
+    }
+  }
+  // Method to check if a directory exists
+  static dirExists(directory, create_directory = false, return_dir_path = false) {
+    const exist = fs3.existsSync(directory);
+    if (!create_directory) {
+      return exist;
+    }
+    if (!exist) {
+      fs3.mkdirSync(directory);
+    }
+    return return_dir_path ? directory : true;
+  }
+};
+var input_validator_util_default = InputValidatorUtil;
+
+// src/utils/sql_formatter_util.ts
+var SqlFormatterUtil = class _SqlFormatterUtil {
+  // Basic ANSI color helpers
+  static AnsiColor = {
+    reset: "\x1B[0m",
+    cyan: (text) => `\x1B[36m${text}\x1B[0m`,
+    green: (text) => `\x1B[32m${text}\x1B[0m`,
+    yellow: (text) => `\x1B[33m${text}\x1B[0m`,
+    red: (text) => `\x1B[31m${text}\x1B[0m`
+  };
+  static sqlColors = {
+    SELECT: _SqlFormatterUtil.AnsiColor.cyan,
+    INSERT: _SqlFormatterUtil.AnsiColor.green,
+    UPDATE: _SqlFormatterUtil.AnsiColor.yellow,
+    DELETE: _SqlFormatterUtil.AnsiColor.red
+  };
+  /**
+   * Normalize SQL:
+   * - Collapse multiple whitespaces/newlines
+   * - Remove extra spaces inside parentheses
+   */
+  static normalize(sql) {
+    return sql.replace(/\s+/g, " ").replace(/\(\s+/g, "(").replace(/\s+\)/g, ")").trim();
+  }
+  /**
+   * Colorize SQL keywords (SELECT, INSERT, UPDATE, DELETE)
+   */
+  static colorize(sql) {
+    const first_word = sql.split(" ")[0].toUpperCase();
+    const colorFN = this.sqlColors[first_word];
+    return colorFN ? colorFN(sql) : sql;
+  }
+  /**
+   * Full formatting for logging
+   */
+  static format(sql) {
+    return this.colorize(this.normalize(sql));
+  }
+};
+var sql_formatter_util_default = SqlFormatterUtil;
+
+// src/utils/server_util.ts
+var ServerUtil = class {
+  name = "server_util";
+  logger = new logger_util_default(this.name);
+  port;
+  constructor(port) {
+    this.port = port || 4e3;
+  }
+  // Method to print app banner
+  printAppBanner(app_name) {
+    const raw = app_name.replace(/[-_]/g, " ");
+    const title = raw.toUpperCase();
+    const border_char = "\u2550";
+    const corner_tl = "\u2554";
+    const corner_tr = "\u2557";
+    const corner_bl = "\u255A";
+    const corner_br = "\u255D";
+    const side_char = "\u2551";
+    const padding = 4;
+    const content_width = title.length + padding * 2;
+    const border = border_char.repeat(content_width);
+    const line1 = `${corner_tl}${border}${corner_tr}`;
+    const line2 = `${side_char} ${" ".repeat(padding)}${title}${" ".repeat(padding)}${side_char} `;
+    const line3 = `${corner_bl}${border}${corner_br}    `;
+    console.log("\n" + line1);
+    console.log(line2);
+    console.log(line3 + "\n");
+  }
+  // Method to handle server errors
+  onServerError(error) {
+    if (error.syscall !== "listen") {
+      this.logger.error("Unexpected server error", { error });
+      throw error;
+    }
+    const bind = `Port ${this.port}`;
+    switch (error.code) {
+      case "EACCES":
+        this.logger.error(`${bind} requires elevated privileges`);
+        process.exit(1);
+        break;
+      case "EADDRINUSE":
+        this.logger.error(`${bind} is already in use`);
+        process.exit(1);
+        break;
+      default:
+        throw error;
+    }
+  }
+  // Method to handle server listening
+  onServerListening = (server) => {
+    this.printAppBanner("fibase-server-app");
+    const addr = server.address();
+    const bind = typeof addr === "string" ? `pipe ${addr}` : `port ${addr?.port}`;
+    this.logger.info(`Listening on ${bind}`);
+  };
+};
+var server_util_default = ServerUtil;
+
+// src/utils/safe_execute_util.ts
+var SafeExecuteUtil = class _SafeExecuteUtil {
+  // Store instances by class constructor (WeakMap ensures GC can clean up)
+  static instances = /* @__PURE__ */ new WeakMap();
+  // Store instances by string keys (Map keeps strong references)
+  static named_insatnces = /* @__PURE__ */ new Map();
+  static setInstance(key, instance) {
+    _SafeExecuteUtil.instances.set(key, instance);
+  }
+  /** Set instance by string key */
+  static setNamedInstance(key, instance) {
+    _SafeExecuteUtil.named_insatnces.set(key, instance);
+  }
+  static getInstance(key, fallback) {
+    return _SafeExecuteUtil.instances.get(key) ?? fallback;
+  }
+  /** Get instance by string key */
+  static getNamedInstance(key, fallback) {
+    return _SafeExecuteUtil.named_insatnces.get(key) ?? fallback;
+  }
+  // Method to Safely stringify any object for logging
+  static safeStringify(obj) {
+    try {
+      return JSON.stringify(obj);
+    } catch {
+      return "[Unserializable Params]";
+    }
+  }
+  // 🔹 Method to Execution time logger
+  static logExecutionTime(start, class_name, method_name, logger) {
+    const [seconds, nanoseconds] = process.hrtime(start);
+    const ms = (seconds * 1e3 + nanoseconds / 1e6).toFixed(2);
+    logger.info(`[${class_name}] \u23F1\uFE0F ${method_name} executed in ${ms}ms`);
+  }
+  // Method to handle on error action
+  static handleOnErrorAction(error, strategy, default_value, controller_response) {
+    if (strategy === 3 /* CONTROLLER_ERROR */ && controller_response?.errResponse) {
+      return controller_response?.errResponse?.(500, "invalid_error_request");
+    }
+    switch (strategy) {
+      case 0 /* RETURN_DEFAULT */:
+        return default_value;
+      case 1 /* EXIT_PROCESS */:
+        process.exit(1);
+      case 2 /* THROW_ERROR */:
+        throw error;
+    }
+    return;
+  }
+  // 🔹 Method to Unifysafe execution wrapper (normal methods)
+  static createSafeFunction(class_name, method_name, original_method, strategy, default_value) {
+    return async function(...args) {
+      const class_instance = _SafeExecuteUtil.getNamedInstance(class_name, this);
+      const logger = class_instance?.logger || new logger_util_default(class_name);
+      const method_params = args;
+      try {
+        return await original_method.apply(class_instance, method_params);
+      } catch (error) {
+        const safely_stringified_error = _SafeExecuteUtil.safeStringify(error);
+        logger.error(`[${class_name}] \u274C Error in method ${method_name}`, { method_params, error, safely_stringified_error });
+        _SafeExecuteUtil.handleOnErrorAction(error, strategy, default_value);
+      }
+    };
+  }
+  // 🔹 Unified safe execution wrapper with timing (for controller/service)
+  static createTimedSafeFunction(class_name, method_name, original_method, strategy, default_value) {
+    return async function(...args) {
+      const class_instance = _SafeExecuteUtil.getNamedInstance(class_name, this);
+      const logger = class_instance?.logger || new logger_util_default(class_name);
+      const start_time = process.hrtime();
+      const method_params = args;
+      const controller_response = args && args.length ? args[1] : void 0;
+      try {
+        const result = await original_method.apply(class_instance, args);
+        return result;
+      } catch (error) {
+        const safely_stringified_error = _SafeExecuteUtil.safeStringify(error);
+        logger.error(`[${class_name}] \u274C Error in method ${method_name}`, { method_params, error, safely_stringified_error });
+        _SafeExecuteUtil.handleOnErrorAction(error, strategy, default_value, controller_response);
+      } finally {
+        _SafeExecuteUtil.logExecutionTime(start_time, class_name, method_name, logger);
+      }
+    };
+  }
+  // Decorator Method to handle wrapping cclass methods
+  static applySafeWrapper(target, class_name, property_key, descriptor, strategy, timed, default_value) {
+    if (typeof descriptor.value !== "function") {
+      return;
+    }
+    descriptor.value = timed ? _SafeExecuteUtil.createTimedSafeFunction(
+      class_name,
+      String(property_key),
+      descriptor.value,
+      strategy,
+      default_value
+    ) : _SafeExecuteUtil.createSafeFunction(
+      class_name,
+      String(property_key),
+      descriptor.value,
+      strategy,
+      default_value
+    );
+  }
+  // Decorator method to handle controller methods
+  static safeExecuteController(class_name) {
+    return function(target, property_key, descriptor) {
+      return _SafeExecuteUtil.applySafeWrapper(
+        target,
+        class_name,
+        property_key,
+        descriptor,
+        3 /* CONTROLLER_ERROR */,
+        true
+      );
+    };
+  }
+  // Decorator Method to handle service methods
+  static safeExecuteService(class_name, default_value) {
+    return function(target, property_key, descriptor) {
+      return _SafeExecuteUtil.applySafeWrapper(
+        target,
+        class_name,
+        property_key,
+        descriptor,
+        0 /* RETURN_DEFAULT */,
+        true,
+        default_value
+      );
+    };
+  }
+  // Decorator Method to wrap method with retrun value
+  static safeExecuteReturn(class_name, default_value) {
+    return function(target, property_key, descriptor) {
+      return _SafeExecuteUtil.applySafeWrapper(
+        target,
+        class_name,
+        property_key,
+        descriptor,
+        0 /* RETURN_DEFAULT */,
+        false,
+        default_value
+      );
+    };
+  }
+  // Decorator Method to wrap method with retrun value
+  static safeExecuteTransaction(class_name, default_value) {
+    return function(target, property_key, descriptor) {
+      return _SafeExecuteUtil.applySafeWrapper(
+        target,
+        class_name,
+        property_key,
+        descriptor,
+        0 /* RETURN_DEFAULT */,
+        false,
+        default_value
+      );
+    };
+  }
+  // Decorator method to wrap method with void return
+  static safeExecute(class_name) {
+    return function(target, property_key, descriptor) {
+      return _SafeExecuteUtil.applySafeWrapper(
+        target,
+        class_name,
+        property_key,
+        descriptor,
+        0 /* RETURN_DEFAULT */,
+        false
+      );
+    };
+  }
+  // Decorator method to wrap method with void return
+  static safeExecuteExit(class_name) {
+    return function(target, property_key, descriptor) {
+      return _SafeExecuteUtil.applySafeWrapper(
+        target,
+        class_name,
+        property_key,
+        descriptor,
+        1 /* EXIT_PROCESS */,
+        false
+      );
+    };
+  }
+  // Decorator method to wrap method with void return
+  static safeExecuteThrow(class_name) {
+    return function(target, property_key, descriptor) {
+      return _SafeExecuteUtil.applySafeWrapper(
+        target,
+        class_name,
+        property_key,
+        descriptor,
+        2 /* THROW_ERROR */,
+        false
+      );
+    };
+  }
+};
+var safe_execute_util_default = SafeExecuteUtil;
+
+// src/utils/cache_util.ts
+var InMemoryCache = class {
+  store = /* @__PURE__ */ new Map();
+  /**
+   * Set a cache value with TTL (ms)
+   */
+  set(key, value, ttl_ms) {
+    if (!key) return;
+    const expires_at = Date.now() + ttl_ms;
+    this.store.set(key, { value, expires_at });
+  }
+  /**
+   * Get a cache value (returns undefined if missing or expired)
+   */
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expires_at) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  /**
+   * Check if a key exists and is valid
+   */
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  /**
+   * Update an existing cache entry (keeps old TTL)
+   */
+  update(key, value) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expires_at) {
+      this.store.delete(key);
+      return false;
+    }
+    this.store.set(key, { ...entry, value });
+    return true;
+  }
+  /**
+   * Delete a single cache entry
+   */
+  delete(key) {
+    return this.store.delete(key);
+  }
+  /**
+   * Clear entire cache
+   */
+  clear() {
+    this.store.clear();
+  }
+  /**
+   * Manually expire a key immediately
+   */
+  expire(key) {
+    this.store.delete(key);
+  }
+  /**
+   * Cleanup expired entries (optional call)
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (now > entry.expires_at) {
+        this.store.delete(key);
+      }
+    }
+  }
+  /**
+   * Cache size (for metrics)
+   */
+  size() {
+    return this.store.size;
+  }
+};
+var cache_util_default = InMemoryCache;
+
+export {
+  SCHEMAS_DIR,
+  SCHEMA_SNAPSHOTS_DIR,
+  MIGRATIONS_DIR,
+  SEEDERS_DIR,
+  SEQUELIZE_META_TABLE_NAME,
+  SEQUELIZE_SEEDER_META_TABLE_NAME,
+  logger_util_default,
+  input_transformer_util_default,
+  env_manager_util_default,
+  input_validator_util_default,
+  sql_formatter_util_default,
+  server_util_default,
+  safe_execute_util_default,
+  cache_util_default
+};
+//# sourceMappingURL=chunk-BK6YPN2O.js.map