@ix-xs/node-comfort 1.0.53 → 1.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ix-xs/node-comfort",
-	"version": "1.0.53",
+	"version": "1.0.55",
 	"description": "",
 	"main": "index.js",
 	"types": "types/index.d.ts",

package/src/localStorage.js

@@ -3,8 +3,10 @@ const checker = require("./checker");
 
 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"))) {
+  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);
@@ -32,7 +34,10 @@ module.exports = class localStorage {
   #exec(sql, options = []) {
     try {
       const stmt = this.#$.prepare(sql);
-      const result = stmt.run(...checker.isArray(options) ? options : [options]);
+      const result = checker.isArray(options)
+        ? stmt.run(...options)
+        : stmt.run(options);
+
       return {
         changes: result.changes,
         lastInsertRowid: result.lastInsertRowid,
@@ -41,26 +46,32 @@ module.exports = class localStorage {
       throw error;
     }
   }
+
   #buildCreateSQL(tableName, options) {
-    const columns = Object.entries(options).map(([col, def]) => {
-      let colDef = `${col} ${def.type}`;
+    const columns = Object.entries(options)
+      .map(([col, def]) => {
+        let colDef = `${col} ${def.type}`;
 
-      if (def.primaryKey) {
-        colDef += " PRIMARY KEY";
-        if (def.autoincrement) colDef += " AUTOINCREMENT";
-      }
-      if (def.notNull) colDef += " NOT NULL";
-      if (def.unique) colDef += " UNIQUE";
-      if (def.defaultValue !== undefined) colDef += ` DEFAULT ${JSON.stringify(def.defaultValue)}`;
-      if (def.values?.length) {
-        colDef += ` CHECK(${col} IN (${def.values.map(v => JSON.stringify(v)).join(", ")}))`;
-      }
+        if (def.primaryKey) {
+          colDef += " PRIMARY KEY";
+          if (def.autoincrement) colDef += " AUTOINCREMENT";
+        }
+        if (def.notNull) colDef += " NOT NULL";
+        if (def.unique) colDef += " UNIQUE";
+        if (def.defaultValue !== undefined) {
+          colDef += ` DEFAULT ${JSON.stringify(def.defaultValue)}`;
+        }
+        if (def.values?.length) {
+          colDef += ` CHECK(${col} IN (${def.values.map(v => JSON.stringify(v)).join(", ")}))`;
+        }
 
-      return colDef;
-    }).join(", ");
+        return colDef;
+      })
+      .join(", ");
 
     return `CREATE TABLE IF NOT EXISTS ${tableName} (${columns})`;
   }
+
   #defineModel(tableName, options) {
     if (this.#models.has(tableName)) return;
 
@@ -68,8 +79,9 @@ module.exports = class localStorage {
     this.#exec(createSQL);
     this.#models.set(tableName, { name: tableName, options });
   }
-  #buildWhere(where) {
-    if (Object.keys(where).length === 0) {
+
+  #buildWhere(where = {}) {
+    if (!where || Object.keys(where).length === 0) {
       return { where: "", params: [] };
     }
 
@@ -86,6 +98,7 @@ module.exports = class localStorage {
       params,
     };
   }
+
   #getOrderBy(tableName) {
     const model = this.#models.get(tableName);
     if (!model) return "id DESC";
@@ -94,15 +107,17 @@ module.exports = class localStorage {
   }
 
   /**
-   * @param {{name: string, options: Record<string, {
-   * type: "TEXT"|"INTEGER"|"REAL"|"BLOB"|"NUMERIC"|"DATE"|"DATETIME"|"TIMESTAMP"|"TIME"|"VARCHAR"|"CHAR"|"CLOB",
+   * @param {object} table
+   * @param {string} table.name
+   * @param {Record<string, {
+   * type: "INTEGER"|"TEXT"|"REAL"|"BLOB"|"NUMERIC",
    * primaryKey?: boolean,
-   * unique?: boolean,
-   * notNull: boolean,
-   * defaultValue?: any,
-   * values?: Array<string>
    * autoincrement?: boolean,
-   * }>}} table
+   * notNull?: boolean,
+   * unique?: boolean,
+   * defaultValue?: *,
+   * values?: Array<*>
+   * }>} table.options
    */
   async createTable(table) {
     try {
@@ -112,12 +127,15 @@ module.exports = class localStorage {
       return { error: error.message };
     }
   }
+
   /**
    * @param {string} tableName
    */
   async deleteTable(tableName) {
     try {
-      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+      if (!this.#models.has(tableName)) {
+        return { error: `Table ${tableName} doesn't exist` };
+      }
 
       this.#exec(`DROP TABLE IF EXISTS ${tableName}`);
       this.#models.delete(tableName);
@@ -126,12 +144,15 @@ module.exports = class localStorage {
       return { error: error.message };
     }
   }
+
   /**
    * @param {string} tableName
    */
   async clearTable(tableName) {
     try {
-      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+      if (!this.#models.has(tableName)) {
+        return { error: `Table ${tableName} doesn't exist` };
+      }
 
       this.#exec(`DELETE FROM ${tableName}`);
       return { ok: true };
@@ -139,9 +160,10 @@ module.exports = class localStorage {
       return { error: error.message };
     }
   }
+
   /**
    * @param {string} tableName
-   * @param {object} [where]
+   * @param {object} where
    */
   async get(tableName, where) {
     try {
@@ -150,24 +172,28 @@ module.exports = class localStorage {
       const whereClause = this.#buildWhere(where);
       const sql = `SELECT * FROM ${tableName} ${whereClause.where} LIMIT 1`;
       const stmt = this.#$.prepare(sql);
-      const record = stmt.get(whereClause.params);
+      const record = stmt.get(...whereClause.params);
+
       return record || undefined;
     } catch (error) {
       return { error: error.message };
     }
   }
+
   /**
    * @param {string} tableName
-   * @param {object} [where]
-   * @param {number} [limit]
-   * @param {number} [offset]
+   * @param {object} where
+   * @param {number} limit
+   * @param {number} offset
    */
   async getAll(tableName, where = {}, limit = 50, offset = 0) {
     try {
       if (!this.#models.has(tableName)) return [];
 
       const whereClause = this.#buildWhere(where);
-      const sql = `SELECT * FROM ${tableName} ${whereClause.where} ORDER BY ${this.#getOrderBy(tableName)} LIMIT ? OFFSET ?`;
+      const sql = `SELECT * FROM ${tableName} ${whereClause.where} ORDER BY ${this.#getOrderBy(
+        tableName,
+      )} LIMIT ? OFFSET ?`;
       const stmt = this.#$.prepare(sql);
       const records = stmt.all(...whereClause.params, limit, offset);
       return records;
@@ -175,43 +201,44 @@ module.exports = class localStorage {
       return { error: error.message };
     }
   }
+
   /**
    * @param {string} tableName
    * @param {*} data
-   * @param {object} [where]
+   * @param {object} where
    */
   async set(tableName, data, where = null) {
     try {
-      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+      if (!this.#models.has(tableName)) {
+        return { error: `Table ${tableName} doesn't exist` };
+      }
 
       const lookup = where ?? (data.id ? { id: data.id } : null);
 
-      if (lookup) {
-        const columns = Object.keys(data).join(", ");
-        const placeholders = Object.keys(data).map(() => "?").join(", ");
-        const sql = `INSERT OR REPLACE INTO ${tableName} (${columns}) VALUES (${placeholders})`;
-        const stmt = this.#$.prepare(sql);
-        stmt.run(...Object.values(data));
-        return { ok: true };
-      } else {
-        const columns = Object.keys(data).join(", ");
-        const placeholders = Object.keys(data).map(() => "?").join(", ");
-        const sql = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
-        const stmt = this.#$.prepare(sql);
-        stmt.run(...Object.values(data));
-        return { ok: true };
-      }
+      const columns = Object.keys(data).join(", ");
+      const placeholders = Object.keys(data).map(() => "?").join(", ");
+      const sql = lookup
+        ? `INSERT OR REPLACE INTO ${tableName} (${columns}) VALUES (${placeholders})`
+        : `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
+
+      const stmt = this.#$.prepare(sql);
+      stmt.run(...Object.values(data));
+
+      return { ok: true };
     } catch (error) {
       return { error: error.message };
     }
   }
+
   /**
    * @param {string} tableName
    * @param {object} where
    */
   async delete(tableName, where) {
     try {
-      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+      if (!this.#models.has(tableName)) {
+        return { error: `Table ${tableName} doesn't exist` };
+      }
 
       const whereClause = this.#buildWhere(where);
       const sql = `DELETE FROM ${tableName} ${whereClause.where}`;
@@ -222,13 +249,16 @@ module.exports = class localStorage {
       return { error: error.message };
     }
   }
+
   /**
    * @param {string} tableName
-   * @param {object} where
+   * @param {object} [where]
    */
   async count(tableName, where = {}) {
     try {
-      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+      if (!this.#models.has(tableName)) {
+        return { error: `Table ${tableName} doesn't exist` };
+      }
 
       const whereClause = this.#buildWhere(where);
       const sql = `SELECT COUNT(*) as total FROM ${tableName} ${whereClause.where}`;