node-red-contrib-db-storage 0.2.0

package/adapters/DatabaseAdapter.js

@@ -0,0 +1,135 @@
+/**
+ * Base DatabaseAdapter class that defines the interface for all database adapters.
+ * All database-specific adapters must extend this class and implement all methods.
+ *
+ * Standardized Configuration Interface:
+ * @typedef {Object} AdapterConfig
+ * @property {string} url - Required: Database connection URL
+ * @property {string} database - Required: Database name
+ *
+ * All adapters must accept this standardized configuration format.
+ */
+class DatabaseAdapter {
+  constructor(config) {
+    if (new.target === DatabaseAdapter) {
+      throw new Error('DatabaseAdapter is an abstract class and cannot be instantiated directly');
+    }
+    this.validateConfig(config);
+    this.config = config;
+    this.url = config.url;
+    this.databaseName = config.database;
+  }
+
+  /**
+   * Validate the configuration object
+   * @param {AdapterConfig} config - The configuration object
+   * @throws {Error} If required fields are missing
+   */
+  validateConfig(config) {
+    if (!config) {
+      throw new Error('Configuration is required');
+    }
+    if (!config.url) {
+      throw new Error('Database URL (config.url) is required');
+    }
+    if (!config.database) {
+      throw new Error('Database name (config.database) is required');
+    }
+  }
+
+  /**
+   * Validate collection/table name to prevent SQL injection
+   * @param {string} collectionName - The collection/table name
+   * @throws {Error} If name is invalid
+   */
+  validateCollectionName(collectionName) {
+    if (!collectionName || typeof collectionName !== 'string') {
+      throw new Error('Collection name must be a non-empty string');
+    }
+    // Only allow alphanumeric, hyphens, and underscores
+    if (!/^[a-zA-Z0-9_-]+$/.test(collectionName)) {
+      throw new Error('Collection name contains invalid characters. Only alphanumeric, hyphens, and underscores are allowed');
+    }
+  }
+
+  /**
+   * Validate objects array
+   * @param {Array} objects - Array of objects to validate
+   * @throws {Error} If not a valid array
+   */
+  validateObjectArray(objects) {
+    if (!Array.isArray(objects)) {
+      throw new Error('Objects must be an array');
+    }
+  }
+
+  /**
+   * Validate path parameter
+   * @param {string} path - The path to validate
+   * @throws {Error} If path is invalid
+   */
+  validatePath(path) {
+    if (!path || typeof path !== 'string') {
+      throw new Error('Path must be a non-empty string');
+    }
+  }
+
+  /**
+   * Connect to the database
+   * @returns {Promise<void>}
+   */
+  async connect() {
+    throw new Error('Method connect() must be implemented');
+  }
+
+  /**
+   * Close the database connection
+   * @returns {Promise<void>}
+   */
+  async close() {
+    throw new Error('Method close() must be implemented');
+  }
+
+  /**
+   * Find all documents/rows in a collection/table
+   * @param {string} collectionName - The collection/table name
+   * @returns {Promise<Array>} Array of documents/rows
+   */
+  async findAll(collectionName) {
+    throw new Error('Method findAll() must be implemented');
+  }
+
+  /**
+   * Save all objects to a collection/table (replaces existing data)
+   * @param {string} collectionName - The collection/table name
+   * @param {Array} objects - Array of objects to save
+   * @returns {Promise<void>}
+   */
+  async saveAll(collectionName, objects) {
+    throw new Error('Method saveAll() must be implemented');
+  }
+
+  /**
+   * Find a single document/row by path
+   * @param {string} collectionName - The collection/table name
+   * @param {string} path - The path to search for
+   * @returns {Promise<Object>} The document body or empty object
+   */
+  async findOneByPath(collectionName, path) {
+    throw new Error('Method findOneByPath() must be implemented');
+  }
+
+  /**
+   * Save or update a document/row by path (upsert)
+   * @param {string} collectionName - The collection/table name
+   * @param {string} path - The path identifier
+   * @param {Object} meta - Metadata object
+   * @param {*} body - The body content
+   * @returns {Promise<void>}
+   */
+  async saveOrUpdateByPath(collectionName, path, meta, body) {
+    throw new Error('Method saveOrUpdateByPath() must be implemented');
+  }
+}
+
+module.exports = DatabaseAdapter;

package/adapters/MongoAdapter.js

@@ -0,0 +1,187 @@
+const DatabaseAdapter = require("./DatabaseAdapter");
+const MongoDB = require("mongodb");
+const MongoClient = MongoDB.MongoClient;
+
+/**
+ * MongoDB adapter for Node-RED storage
+ *
+ * Configuration:
+ * @param {Object} config - Standardized adapter configuration
+ * @param {string} config.url - MongoDB connection URL (e.g., 'mongodb://localhost:27017')
+ * @param {string} config.database - Database name to use
+ */
+class MongoAdapter extends DatabaseAdapter {
+  constructor(config) {
+    super(config);
+    // url and databaseName are set by parent class
+    this.client = null;
+    this.db = null;
+  }
+
+  async connect() {
+    return new Promise((resolve, reject) => {
+      MongoClient.connect(
+        this.url,
+        { useUnifiedTopology: true },
+        (err, client) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          this.client = client;
+          this.db = client.db(this.databaseName);
+          resolve();
+        },
+      );
+    });
+  }
+
+  async close() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+      this.db = null;
+    }
+  }
+
+  /**
+   * Replace $ keys with __dollar__ to avoid MongoDB restrictions
+   */
+  _escapeDollarKeys(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this._escapeDollarKeys(item));
+    }
+
+    const result = {};
+    for (const key in obj) {
+      const newKey = key === "$" ? "__dollar__" : key;
+      result[newKey] = this._escapeDollarKeys(obj[key]);
+    }
+    return result;
+  }
+
+  /**
+   * Restore __dollar__ back to $ keys
+   */
+  _restoreDollarKeys(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this._restoreDollarKeys(item));
+    }
+
+    const result = {};
+    for (const key in obj) {
+      const newKey = key === "__dollar__" ? "$" : key;
+      result[newKey] = this._restoreDollarKeys(obj[key]);
+    }
+    return result;
+  }
+
+  async findAll(collectionName) {
+    this.validateCollectionName(collectionName);
+    return new Promise((resolve, reject) => {
+      this.db
+        .collection(collectionName)
+        .find({})
+        .toArray((err, documents) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          if (documents == null) {
+            resolve([]);
+          } else {
+            // Remove MongoDB _id field and restore $ keys
+            resolve(
+              documents.map((doc) => {
+                const { _id, ...data } = doc;
+                return this._restoreDollarKeys(data);
+              }),
+            );
+          }
+        });
+    });
+  }
+
+  async saveAll(collectionName, objects) {
+    this.validateCollectionName(collectionName);
+    this.validateObjectArray(objects);
+    await this._dropCollectionIfExists(collectionName);
+
+    if (objects.length > 0) {
+      // Escape $ keys to avoid MongoDB restrictions
+      const escapedObjects = objects.map((obj) => this._escapeDollarKeys(obj));
+      await this.db.collection(collectionName).insertMany(escapedObjects);
+    }
+  }
+
+  async _dropCollectionIfExists(collectionName) {
+    const collections = await this.db
+      .listCollections({ name: collectionName })
+      .toArray();
+
+    if (collections.length > 0) {
+      await this.db.collection(collectionName).drop();
+    }
+  }
+
+  async findOneByPath(collectionName, path) {
+    this.validateCollectionName(collectionName);
+    this.validatePath(path);
+    return new Promise((resolve, reject) => {
+      this.db
+        .collection(collectionName)
+        .findOne({ path: path }, (err, document) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          if (document == null) {
+            resolve({});
+          } else if (document.body) {
+            const body =
+              typeof document.body === "string"
+                ? JSON.parse(document.body)
+                : document.body;
+            resolve(this._restoreDollarKeys(body));
+          } else {
+            resolve({});
+          }
+        });
+    });
+  }
+
+  async saveOrUpdateByPath(collectionName, path, meta, body) {
+    this.validateCollectionName(collectionName);
+    this.validatePath(path);
+    return new Promise((resolve, reject) => {
+      const document = {
+        path: path,
+        meta: JSON.stringify(meta),
+        body: JSON.stringify(body),
+      };
+
+      this.db
+        .collection(collectionName)
+        .replaceOne({ path: path }, document, { upsert: true }, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+    });
+  }
+}
+
+module.exports = MongoAdapter;

package/adapters/MySQLAdapter.js

@@ -0,0 +1,172 @@
+const DatabaseAdapter = require("./DatabaseAdapter");
+
+/**
+ * MySQL/MariaDB adapter for Node-RED storage
+ *
+ * Configuration:
+ * @param {Object} config - Standardized adapter configuration
+ * @param {string} config.url - MySQL connection URL (e.g., 'mysql://user:password@localhost:3306/dbname')
+ * @param {string} config.database - Database name to use
+ */
+class MySQLAdapter extends DatabaseAdapter {
+  constructor(config) {
+    super(config);
+    // url and databaseName are set by parent class
+    this.pool = null;
+    this._mysql = null;
+  }
+
+  async connect() {
+    // Dynamically require mysql2 to make it an optional dependency
+    try {
+      this._mysql = require("mysql2/promise");
+    } catch (err) {
+      throw new Error(
+        'MySQL adapter requires the "mysql2" package. Install it with: npm install mysql2',
+      );
+    }
+
+    this.pool = this._mysql.createPool(this.url);
+
+    // Test the connection
+    const connection = await this.pool.getConnection();
+    connection.release();
+
+    // Create tables if they don't exist
+    await this._initializeTables();
+  }
+
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+
+  async _initializeTables() {
+    // We'll create tables dynamically as needed
+    // This is a helper to ensure the schema exists
+  }
+
+  async _ensureTable(tableName) {
+    const createTableQuery = `
+      CREATE TABLE IF NOT EXISTS \`${tableName}\` (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        path VARCHAR(512) UNIQUE,
+        data JSON NOT NULL,
+        meta JSON,
+        body JSON,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      )
+    `;
+    await this.pool.query(createTableQuery);
+
+    // Create index on path for faster lookups (MySQL doesn't support IF NOT EXISTS for indexes)
+    const createIndexQuery = `
+      CREATE INDEX \`${tableName}_path_idx\` ON \`${tableName}\` (path)
+    `;
+    try {
+      await this.pool.query(createIndexQuery);
+    } catch (err) {
+      // Index might already exist, ignore error
+      if (!err.message.includes("Duplicate key name")) {
+        throw err;
+      }
+    }
+  }
+
+  async findAll(collectionName) {
+    this.validateCollectionName(collectionName);
+    await this._ensureTable(collectionName);
+
+    const query = `SELECT data FROM \`${collectionName}\``;
+    const [rows] = await this.pool.query(query);
+
+    if (rows.length === 0) {
+      return [];
+    }
+
+    return rows.map((row) => row.data);
+  }
+
+  async saveAll(collectionName, objects) {
+    this.validateCollectionName(collectionName);
+    this.validateObjectArray(objects);
+    await this._ensureTable(collectionName);
+
+    // Start a transaction
+    const connection = await this.pool.getConnection();
+
+    try {
+      await connection.beginTransaction();
+
+      // Delete all existing data
+      await connection.query(`DELETE FROM \`${collectionName}\``);
+
+      // Insert new data
+      if (objects.length > 0) {
+        for (const obj of objects) {
+          await connection.query(
+            `INSERT INTO \`${collectionName}\` (data) VALUES (?)`,
+            [JSON.stringify(obj)],
+          );
+        }
+      }
+
+      await connection.commit();
+    } catch (err) {
+      await connection.rollback();
+      throw err;
+    } finally {
+      connection.release();
+    }
+  }
+
+  async findOneByPath(collectionName, path) {
+    this.validateCollectionName(collectionName);
+    this.validatePath(path);
+    await this._ensureTable(collectionName);
+
+    const query = `SELECT body FROM \`${collectionName}\` WHERE path = ?`;
+    const [rows] = await this.pool.query(query, [path]);
+
+    if (rows.length === 0) {
+      return {};
+    }
+
+    const body = rows[0].body;
+    if (body == null) {
+      return {};
+    }
+
+    return body;
+  }
+
+  async saveOrUpdateByPath(collectionName, path, meta, body) {
+    this.validateCollectionName(collectionName);
+    this.validatePath(path);
+    await this._ensureTable(collectionName);
+
+    const query = `
+      INSERT INTO \`${collectionName}\` (path, meta, body, data, updated_at)
+      VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+      ON DUPLICATE KEY UPDATE
+        meta = VALUES(meta),
+        body = VALUES(body),
+        data = VALUES(data),
+        updated_at = CURRENT_TIMESTAMP
+    `;
+
+    const data = { path, meta, body };
+
+    await this.pool.query(query, [
+      path,
+      JSON.stringify(meta),
+      JSON.stringify(body),
+      JSON.stringify(data),
+    ]);
+  }
+}
+
+module.exports = MySQLAdapter;

package/adapters/PostgresAdapter.js

@@ -0,0 +1,167 @@
+const DatabaseAdapter = require('./DatabaseAdapter');
+
+/**
+ * PostgreSQL adapter for Node-RED storage
+ *
+ * Configuration:
+ * @param {Object} config - Standardized adapter configuration
+ * @param {string} config.url - PostgreSQL connection URL (e.g., 'postgresql://user:password@localhost:5432/dbname')
+ * @param {string} config.database - Database name (should match the database in the URL)
+ */
+class PostgresAdapter extends DatabaseAdapter {
+  constructor(config) {
+    super(config);
+    // url and databaseName are set by parent class
+    this.connectionString = this.url;
+    this.pool = null;
+    this._pg = null;
+  }
+
+  async connect() {
+    // Dynamically require pg to make it an optional dependency
+    try {
+      this._pg = require('pg');
+    } catch (err) {
+      throw new Error('PostgreSQL adapter requires the "pg" package. Install it with: npm install pg');
+    }
+
+    this.pool = new this._pg.Pool({
+      connectionString: this.connectionString
+    });
+
+    // Test the connection
+    const client = await this.pool.connect();
+    client.release();
+
+    // Create tables if they don't exist
+    await this._initializeTables();
+  }
+
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+
+  async _initializeTables() {
+    // We'll create tables dynamically as needed
+    // This is a helper to ensure the schema exists
+  }
+
+  async _ensureTable(tableName) {
+    const createTableQuery = `
+      CREATE TABLE IF NOT EXISTS "${tableName}" (
+        id SERIAL PRIMARY KEY,
+        path VARCHAR(512) UNIQUE,
+        data JSONB NOT NULL,
+        meta JSONB,
+        body JSONB,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+    await this.pool.query(createTableQuery);
+
+    // Create index on path for faster lookups
+    const createIndexQuery = `
+      CREATE INDEX IF NOT EXISTS "${tableName}_path_idx" ON "${tableName}" (path)
+    `;
+    await this.pool.query(createIndexQuery);
+  }
+
+  async findAll(collectionName) {
+    this.validateCollectionName(collectionName);
+    await this._ensureTable(collectionName);
+
+    const query = `SELECT data FROM "${collectionName}"`;
+    const result = await this.pool.query(query);
+
+    if (result.rows.length === 0) {
+      return [];
+    }
+
+    return result.rows.map(row => row.data);
+  }
+
+  async saveAll(collectionName, objects) {
+    this.validateCollectionName(collectionName);
+    this.validateObjectArray(objects);
+    await this._ensureTable(collectionName);
+
+    // Start a transaction
+    const client = await this.pool.connect();
+
+    try {
+      await client.query('BEGIN');
+
+      // Delete all existing data
+      await client.query(`DELETE FROM "${collectionName}"`);
+
+      // Insert new data
+      if (objects.length > 0) {
+        for (const obj of objects) {
+          await client.query(
+            `INSERT INTO "${collectionName}" (data) VALUES ($1)`,
+            [JSON.stringify(obj)]
+          );
+        }
+      }
+
+      await client.query('COMMIT');
+    } catch (err) {
+      await client.query('ROLLBACK');
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+
+  async findOneByPath(collectionName, path) {
+    this.validateCollectionName(collectionName);
+    this.validatePath(path);
+    await this._ensureTable(collectionName);
+
+    const query = `SELECT body FROM "${collectionName}" WHERE path = $1`;
+    const result = await this.pool.query(query, [path]);
+
+    if (result.rows.length === 0) {
+      return {};
+    }
+
+    const body = result.rows[0].body;
+    if (body == null) {
+      return {};
+    }
+
+    return body;
+  }
+
+  async saveOrUpdateByPath(collectionName, path, meta, body) {
+    this.validateCollectionName(collectionName);
+    this.validatePath(path);
+    await this._ensureTable(collectionName);
+
+    const query = `
+      INSERT INTO "${collectionName}" (path, meta, body, data, updated_at)
+      VALUES ($1, $2, $3, $4, CURRENT_TIMESTAMP)
+      ON CONFLICT (path)
+      DO UPDATE SET
+        meta = EXCLUDED.meta,
+        body = EXCLUDED.body,
+        data = EXCLUDED.data,
+        updated_at = CURRENT_TIMESTAMP
+    `;
+
+    const data = { path, meta, body };
+
+    await this.pool.query(query, [
+      path,
+      JSON.stringify(meta),
+      JSON.stringify(body),
+      JSON.stringify(data)
+    ]);
+  }
+}
+
+module.exports = PostgresAdapter;