@ix-xs/node-comfort 1.0.0

package/core/Storage.js

@@ -0,0 +1,350 @@
+const FS = require("./FS");
+const Checker = require("./Checker");
+const { basename } = require("node:path");
+
+const originalEmitWarning = process.emitWarning;
+process.emitWarning = (warning, ...args) => {
+  if ((warning.name === "ExperimentalWarning" && warning.message.includes("SQLite")) || (typeof warning === "string" && warning.startsWith("SQLite is an experimental feature"))) {
+    return;
+  }
+
+  return originalEmitWarning.call(process, warning, ...args);
+};
+
+const { DatabaseSync } = require("node:sqlite");
+
+/**
+ * @module Storage
+ */
+
+module.exports = class Storage {
+  #$;
+  #statements = new Map();
+
+  /**
+   * @param {string} [path = ":memomry"]
+   */
+  constructor(path) {
+    if (path.includes("/")) {
+      const split = path.split("/");
+      const file = split[split.length - 1];
+      const folder = FS.createPath(path.replace(file, ""));
+
+      FS.createFolder(folder);
+    }
+
+    this.#$ = new DatabaseSync(path);
+
+    this.exec("PRAGMA journal_mode = WAL");
+    this.exec("PRAGMA foreign_keys = ON");
+    this.exec("PRAGMA synchronous = NORMAL");
+    this.exec("PRAGMA cache_size = -64000");
+  }
+
+  /**
+   * @param {string} sql
+   * @param {array|object} [options = {}]
+   */
+  exec(sql, options) {
+    try {
+      const stmt = this.#$.prepare(sql);
+      const result = stmt.run(...Checker.isArray(options) ? options : [options]);
+
+      return {
+        changes: result.changes,
+        lastInsertRowid: result.lastInsertRowid,
+      };
+
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * @param {string} sql
+   * @param {array|object} [options = []]
+   */
+  getOne(sql, options) {
+    try {
+      const stmt = this.#$.prepare(sql);
+
+      return stmt.get(...Checker.isArray(options) ? options : [options]) || null;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * @param {string} sql
+   * @param {array|object} [options = []]
+   */
+  getAll(sql, options) {
+    try {
+      const stmt = this.#$.prepare(sql);
+
+      return stmt.all(...Checker.isArray(options) ? options : [options]) || [];
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @param {string} sql
+   */
+  prepare(name, sql) {
+    if (this.#statements.has(name)) {
+      return this.#statements.get(name);
+    }
+
+    const stmt = this.#$.prepare(sql);
+
+    this.#statements.set(name, stmt);
+
+    return stmt;
+  }
+
+  /**
+   * @param {string} table
+   * @param {object} schema
+   */
+  createTable(table, schema) {
+    const columns = Object.entries(schema)
+      .map(([key, type]) => `${key} ${type}`)
+      .join(", ");
+
+    const sql = `CREATE TABLE IF NOT EXISTS ${table} (${columns})`;
+
+    this.exec(sql);
+  }
+
+  /**
+   * @param {string} table
+   * @param {object} data
+   */
+  insert(table, data) {
+    const keys = Object.keys(data);
+    const placeholders = keys.map(() => "?").join(", ");
+    const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
+
+    const result = this.exec(sql, Object.values(data));
+
+    return result.lastInsertRowid;
+  }
+
+  /**
+   * @param {string} table
+   * @param {number} id
+   * @returns {object|null}
+   */
+  findById(table, id) {
+    return this.getOne(`SELECT * FROM ${table} WHERE id = ?`, [id]);
+  }
+
+  /**
+   * @param {string} table
+   * @param {object} [where = {}]
+   * @param {object} [options = {}]
+   */
+  findAll(table, where, options) {
+    const { limit = 100, offset = 0, orderBy = "id" } = options;
+
+    let sql = `SELECT * FROM ${table}`;
+
+    if (Object.keys(where).length > 0) {
+      const conditions = Object.keys(where)
+        .map(key => `${key} = ?`)
+        .join(" AND ");
+      sql += ` WHERE ${conditions}`;
+    }
+
+    sql += ` ORDER BY ${orderBy} LIMIT ? OFFSET ?`;
+
+    const params = [...Object.values(where), limit, offset];
+
+    return this.getAll(sql, params);
+  }
+
+  /**
+   * @param {string} table
+   * @param {object} [where]
+   */
+  count(table, where = {}) {
+    let sql = `SELECT COUNT(*) as count FROM ${table}`;
+
+    if (Object.keys(where).length > 0) {
+      const conditions = Object.keys(where)
+        .map(key => `${key} = ?`)
+        .join(" AND ");
+      sql += ` WHERE ${conditions}`;
+    }
+
+    const result = this.getOne(sql, Object.values(where));
+
+    return result?.count || 0;
+  }
+
+  /**
+   * @param {string} table
+   * @param {number} id
+   * @param {object} data
+   */
+  update(table, id, data) {
+    const keys = Object.keys(data);
+    const setClause = keys.map(key => `${key} = ?`).join(", ");
+    const sql = `UPDATE ${table} SET ${setClause} WHERE id = ?`;
+
+    const result = this.exec(sql, [...Object.values(data), id]);
+
+    return result.changes;
+  }
+
+  /**
+   * @param {string} table
+   * @param {number} id
+   */
+  delete(table, id) {
+    const sql = `DELETE FROM ${table} WHERE id = ?`;
+    const result = this.exec(sql, [id]);
+
+    return result.changes;
+  }
+
+  /**
+   * @param {string} table
+   * @param {object} data
+   * @param {string} [conflictColumn]
+   */
+  upsert(table, data, conflictColumn = "id") {
+    const keys = Object.keys(data);
+    const placeholders = keys.map(() => "?").join(", ");
+    const updates = keys
+      .filter(k => k !== conflictColumn)
+      .map(k => `${k} = EXCLUDED.${k}`)
+      .join(", ");
+
+    const sql = `
+      INSERT INTO ${table} (${keys.join(", ")})
+      VALUES (${placeholders})
+      ON CONFLICT(${conflictColumn})
+      DO UPDATE SET ${updates}
+    `;
+
+    return this.exec(sql, Object.values(data));
+  }
+
+  /**
+   * @param {function} callback
+   */
+  transaction(callback) {
+    try {
+      this.exec("BEGIN TRANSACTION");
+
+      const result = callback();
+
+      this.exec("COMMIT");
+
+      return result;
+    } catch (error) {
+      this.exec("ROLLBACK");
+      throw error;
+    }
+  }
+
+  /**
+   * @param {string} migrationsDir - Répertoire contenant les migrations
+   */
+  runMigrations(migrationsDir) {
+    if (!FS.getFolder(migrationsDir)) {
+      FS.createFolder(migrationsDir);
+
+      return;
+    }
+
+    const migrationFiles = FS.getFilesIn(migrationsDir).filter(f => f.endsWith(".sql")).sort();
+
+    this.createTable("__migrations", {
+      name: "TEXT PRIMARY KEY",
+      executed_at: "DATETIME DEFAULT CURRENT_TIMESTAMP",
+    });
+
+    for (const file of migrationFiles) {
+      const migrationName = basename(file, ".sql");
+      const alreadyRun = this.getOne("SELECT * FROM __migrations WHERE name = ?", [migrationName]);
+
+      if (!alreadyRun) {
+        const sql = FS.readFile(`${migrationsDir}/${file}`);
+
+        try {
+          this.exec(sql);
+          this.insert("__migrations", { name: migrationName });
+        } catch (error) {
+          throw error;
+        }
+      }
+    }
+  }
+
+  /**
+   * @param {string} table
+   */
+  export(table) {
+    return this.getAll(`SELECT * FROM ${table}`);
+  }
+
+  /**
+   * @param {string} table
+   * @param {array} data
+   */
+  import(table, data) {
+    let count = 0;
+    this.transaction(() => {
+      for (const row of data) {
+        this.insert(table, row);
+        count++;
+      }
+    });
+    return count;
+  }
+
+  /**
+   * @param {string} table
+   */
+  truncate(table) {
+    this.exec(`DELETE FROM ${table}`);
+  }
+
+  /**
+   * @param {string} indexName
+   * @param {string} table
+   * @param {string} columns
+   */
+  createIndex(indexName, table, columns) {
+    this.exec(`CREATE INDEX IF NOT EXISTS ${indexName} ON ${table} (${columns})`);
+  }
+
+  /**
+   * @returns {object}
+   */
+  stats() {
+    const tables = this.getAll("SELECT name FROM sqlite_master WHERE type='table'");
+    const stats = {};
+
+    for (const { name } of tables) {
+      if (!name.startsWith("__")) {
+        const count = this.count(name);
+        stats[name] = count;
+      }
+    }
+
+    return stats;
+  }
+
+  close() {
+    if (this.db) {
+      this.#$.close();
+      this.#statements.clear();
+      this.#$ = null;
+    }
+  }
+};

package/core/Utils.js

@@ -0,0 +1,206 @@
+const { config } = require("@dotenvx/dotenvx");
+const { log } = require("./Logger");
+
+/**
+ * @module Utils
+ * @description
+ */
+module.exports = {
+  getEnv(env) {
+    config({ quiet: true });
+    return process.env[env];
+  },
+  /**
+	 * Creates a Promise that resolves after specified milliseconds.
+	 *
+	 * @param {number} ms - Milliseconds to wait (positive integer).
+	 * @returns {Promise<void>} Promise that resolves after delay.
+	 *
+	 * @example
+	 * // Sequential delays
+	 * await wait(100);  // 100ms
+	 * await wait(500);  // 500ms
+	 * await wait(2000); // 2 seconds
+	 */
+  wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  },
+  /**
+	 *
+	 * @param {boolean|Promise<boolean>} predicate
+	 * @param {*} handler
+	 * @param {object} [options]
+	 * @param {number} [options.interval]
+	 * @param {number|null} [options.timeout]
+	 * @param {number|null} [options.max]
+	 */
+  when(predicate, handler, options) {
+    const interval = options?.interval ?? 50;
+    const timeout = options?.timeout ?? null;
+    const max = options?.max ?? null;
+
+    const listeners = {
+      trigger: new Set(),
+      error: new Set(),
+      timeout: new Set(),
+    };
+
+    let _timer = null;
+    let _timeoutTimer = null;
+    let _stopped = false;
+    let _count = 0;
+
+    function emit(event, payload) {
+      for (const fn of listeners[event]) {
+        try {
+          fn(payload);
+        } catch (error) {
+          console.error(`[when] listener error on "${event}":`, error);
+        }
+      }
+    }
+
+    async function evalPredicate() {
+      if (typeof predicate === "function") {
+        return await predicate();
+      }
+      return Boolean(predicate);
+    }
+
+    async function tick() {
+      if (_stopped) return;
+
+      try {
+        const ok = await evalPredicate();
+
+        if (ok) {
+          _count++;
+          emit("trigger", handler);
+
+          if (max != null && _count >= max) {
+            _stopInternal();
+            return;
+          }
+        }
+
+        if (!_stopped) {
+          _timer = setTimeout(tick, interval);
+        }
+      } catch (error) {
+        emit("error", error);
+        if (!_stopped) {
+          _timer = setTimeout(tick, interval);
+        }
+      }
+    }
+
+    function _stopInternal() {
+      _stopped = true;
+      if (_timer) {
+        clearTimeout(_timer);
+        _timer = null;
+      }
+      if (_timeoutTimer) {
+        clearTimeout(_timeoutTimer);
+        _timeoutTimer = null;
+      }
+    }
+
+    const api = {
+      start() {
+        if (_stopped) return api;
+
+        if (!_timer) {
+          _timer = setTimeout(tick, 0);
+        }
+
+        if (timeout != null && !_timeoutTimer) {
+          _timeoutTimer = setTimeout(() => {
+            if (_stopped) return;
+            emit("timeout", handler);
+            _stopInternal();
+          }, timeout);
+        }
+
+        return api;
+      },
+      stop() {
+        _stopInternal();
+        return api;
+      },
+      /**
+			 * @param {"error"|"trigger"|"timeout"} event
+			 * @param {(payload: any) => void} fn
+			 */
+      on(event, fn) {
+        listeners[event]?.add(fn);
+        return api;
+      },
+      /**
+			 * @param {"error"|"trigger"|"timeout"} event
+			 * @param {(payload: any) => void} fn
+			 */
+      off(event, fn) {
+        listeners[event]?.delete(fn);
+        return api;
+      },
+    };
+
+    return api;
+  },
+  dontCrash() {
+    const defaults = {
+      error: (error) => {
+        log(
+          `<% red [@ix-xs/node-comfort] Process Error %>\n<% gray ${error.stack ?? error} %>`,
+        );
+      },
+      exit: (code) => {
+        log(
+          `<% yellow [@ix-xs/node-comfort] Process Exit %>\n→ Code: <% gray ${code} %>`,
+        );
+      },
+      sig: (signal) => {
+        log(
+          `<% yellow [@ix-xs/node-comfort] Process SIG* %>\n→ Signal: <% gray ${signal} %>`,
+        );
+
+        process.exit(0);
+      },
+      beforeExit: (code) => {},
+    };
+
+    const _ = {
+      /**
+			 * @template { "error" | "exit" | "sig" | "beforeExit" } E
+			 * @param { E } event
+			 * @param { { error: (error: Error | unknown) => void | Promise<void>, exit: (code: number) => void | Promise<void>, sig: (signal: "SIGINT" | "SIGTERM" | "SIGQUIT") => void | Promise<void>, beforeExit: (code: number) => void|Promise<void> }[E] } handler
+			 */
+      on(event, handler) {
+        if (event === "error") {
+          process.removeAllListeners("uncaughtException");
+          process.removeAllListeners("unhandledRejection");
+          process.on("uncaughtException", handler ?? defaults.error);
+          process.on("unhandledRejection", handler ?? defaults.error);
+        } else if (event === "exit") {
+          process.removeAllListeners("exit");
+          process.on("exit", handler ?? defaults.exit);
+        } else if (event === "sig") {
+          for (const signal of ["SIGINT", "SIGTERM", "SIGQUIT"]) {
+            process.removeAllListeners(signal);
+            process.on(signal, handler ?? defaults.sig);
+          }
+        } else if (event === "beforeExit") {
+          process.removeAllListeners("beforeExit");
+          process.on("beforeExit", handler ?? defaults.beforeExit);
+        }
+
+        return _;
+      },
+    };
+
+    _.on("error").on("exit").on("sig");
+
+    return _;
+  },
+};

package/index.js

@@ -0,0 +1,17 @@
+const Checker = require("./core/Checker");
+const CLI = require("./core/CLI");
+const Storage = require("./core/Storage");
+const FS = require("./core/FS");
+const Logger = require("./core/Logger");
+const Stepper = require("./core/Stepper");
+const Utils = require("./core/Utils");
+
+module.exports = {
+  ...Checker,
+  ...CLI,
+  Storage,
+  ...FS,
+  ...Logger,
+  ...Stepper,
+  ...Utils,
+};

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@ix-xs/node-comfort",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "ix-xs",
+  "dependencies": {
+    "@dotenvx/dotenvx": "^1.51.2"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  }
+}