node-red-contrib-db-storage 0.2.0

package/adapters/SQLiteAdapter.js

@@ -0,0 +1,161 @@
+const DatabaseAdapter = require('./DatabaseAdapter');
+
+/**
+ * SQLite adapter for Node-RED storage
+ *
+ * Configuration:
+ * @param {Object} config - Standardized adapter configuration
+ * @param {string} config.url - SQLite database file path (e.g., '/path/to/database.db' or ':memory:')
+ * @param {string} config.database - Database name (used for identification, not for SQLite file)
+ */
+class SQLiteAdapter extends DatabaseAdapter {
+  constructor(config) {
+    super(config);
+    // url and databaseName are set by parent class
+    this.db = null;
+    this._sqlite = null;
+  }
+
+  async connect() {
+    // Dynamically require better-sqlite3 to make it an optional dependency
+    try {
+      this._sqlite = require('better-sqlite3');
+    } catch (err) {
+      throw new Error('SQLite adapter requires the "better-sqlite3" package. Install it with: npm install better-sqlite3');
+    }
+
+    // Parse the URL to get the file path
+    let dbPath = this.url;
+    if (dbPath.startsWith('sqlite://')) {
+      dbPath = dbPath.replace('sqlite://', '');
+    } else if (dbPath.startsWith('file://')) {
+      dbPath = dbPath.replace('file://', '');
+    }
+
+    this.db = new this._sqlite(dbPath);
+
+    // Enable WAL mode for better concurrent performance
+    this.db.pragma('journal_mode = WAL');
+
+    // Create tables if they don't exist
+    await this._initializeTables();
+  }
+
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = 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 INTEGER PRIMARY KEY AUTOINCREMENT,
+        path TEXT UNIQUE,
+        data TEXT NOT NULL,
+        meta TEXT,
+        body TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+    this.db.exec(createTableQuery);
+
+    // Create index on path for faster lookups
+    const createIndexQuery = `
+      CREATE INDEX IF NOT EXISTS "${tableName}_path_idx" ON "${tableName}" (path)
+    `;
+    this.db.exec(createIndexQuery);
+  }
+
+  async findAll(collectionName) {
+    this.validateCollectionName(collectionName);
+    await this._ensureTable(collectionName);
+
+    const query = `SELECT data FROM "${collectionName}"`;
+    const rows = this.db.prepare(query).all();
+
+    if (rows.length === 0) {
+      return [];
+    }
+
+    return rows.map(row => JSON.parse(row.data));
+  }
+
+  async saveAll(collectionName, objects) {
+    this.validateCollectionName(collectionName);
+    this.validateObjectArray(objects);
+    await this._ensureTable(collectionName);
+
+    // Use a transaction for atomicity
+    const transaction = this.db.transaction((objs) => {
+      // Delete all existing data
+      this.db.prepare(`DELETE FROM "${collectionName}"`).run();
+
+      // Insert new data
+      if (objs.length > 0) {
+        const insert = this.db.prepare(
+          `INSERT INTO "${collectionName}" (data) VALUES (?)`
+        );
+        for (const obj of objs) {
+          insert.run(JSON.stringify(obj));
+        }
+      }
+    });
+
+    transaction(objects);
+  }
+
+  async findOneByPath(collectionName, path) {
+    this.validateCollectionName(collectionName);
+    this.validatePath(path);
+    await this._ensureTable(collectionName);
+
+    const query = `SELECT body FROM "${collectionName}" WHERE path = ?`;
+    const row = this.db.prepare(query).get(path);
+
+    if (!row) {
+      return {};
+    }
+
+    const body = row.body;
+    if (body == null) {
+      return {};
+    }
+
+    return JSON.parse(body);
+  }
+
+  async saveOrUpdateByPath(collectionName, path, meta, body) {
+    this.validateCollectionName(collectionName);
+    this.validatePath(path);
+    await this._ensureTable(collectionName);
+
+    const data = { path, meta, body };
+
+    const query = `
+      INSERT INTO "${collectionName}" (path, meta, body, data, updated_at)
+      VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(path) DO UPDATE SET
+        meta = excluded.meta,
+        body = excluded.body,
+        data = excluded.data,
+        updated_at = CURRENT_TIMESTAMP
+    `;
+
+    this.db.prepare(query).run(
+      path,
+      JSON.stringify(meta),
+      JSON.stringify(body),
+      JSON.stringify(data)
+    );
+  }
+}
+
+module.exports = SQLiteAdapter;

package/adapters/index.js

@@ -0,0 +1,15 @@
+const DatabaseAdapter = require('./DatabaseAdapter');
+const MongoAdapter = require('./MongoAdapter');
+const PostgresAdapter = require('./PostgresAdapter');
+const MySQLAdapter = require('./MySQLAdapter');
+const SQLiteAdapter = require('./SQLiteAdapter');
+const AdapterFactory = require('./AdapterFactory');
+
+module.exports = {
+  DatabaseAdapter,
+  MongoAdapter,
+  PostgresAdapter,
+  MySQLAdapter,
+  SQLiteAdapter,
+  AdapterFactory
+};

package/constants.js

@@ -0,0 +1,8 @@
+module.exports = {
+    DefaultCollectionNames: {
+        flows: "nodered-flows",
+        credentials: "nodered-credentials",
+        settings: "nodered-settings",
+        sessions: "nodered-sessions"
+    }
+}

package/examples/node-red-app.js

@@ -0,0 +1,115 @@
+//npm install http;
+var http = require('http');
+//npm install express
+var express = require("express");
+//npm install node-red
+var RED = require("node-red");
+//npm install util
+var util = require("util");
+
+// Create an Express app
+var app = express();
+
+// Add a simple route for static content served from 'public'
+app.use("/",express.static("public"));
+
+// Create a server
+var server = http.createServer(app);
+
+// Create the settings object - see default settings.js file for other options
+var settings = {
+    httpAdminRoot:"/red",
+    httpNodeRoot: "/api",
+    //on windows
+    userDir:"c:\\node-red-files",
+    //on linux
+    // userDir:"/home/user",
+    uiPort : 1880,
+    uiHost: "localhost",
+    storageModule : require("node-red-mongo-storage-plugin"),
+    storageModuleOptions: {
+        mongoUrl: 'mongodb://localhost:27017',
+        database: 'local',
+        collectionNames:{
+            flows: "nodered-flows",
+            credentials: "nodered-credentials",
+            settings: "nodered-settings",
+            sessions: "nodered-sessions"
+        }
+    }, 
+    functionGlobalContext: { }    // enables global context
+};
+
+// Initialise the runtime with a server and settings
+RED.init(server,settings);
+
+// Serve the editor UI from /red
+app.use(settings.httpAdminRoot,RED.httpAdmin);
+
+// Serve the http nodes UI from /api
+app.use(settings.httpNodeRoot,RED.httpNode);
+
+
+
+function getListenPath() {
+    var port = settings.serverPort;
+    if (port === undefined){
+        port = settings.uiPort;
+    }
+
+    var listenPath = 'http'+(settings.https?'s':'')+'://'+
+                    (settings.uiHost == '::'?'localhost':(settings.uiHost == '0.0.0.0'?'127.0.0.1':settings.uiHost))+
+                    ':'+port;
+    if (settings.httpAdminRoot !== false) {
+        listenPath += settings.httpAdminRoot;
+    } else if (settings.httpStatic) {
+        listenPath += "/";
+    }
+    return listenPath;
+}
+
+RED.start().then(function() {
+    if (settings.httpAdminRoot !== false || settings.httpNodeRoot !== false || settings.httpStatic) {
+        server.on('error', function(err) {
+            if (err.errno === "EADDRINUSE") {
+                RED.log.error(RED.log._("server.unable-to-listen", {listenpath:getListenPath()}));
+                RED.log.error(RED.log._("server.port-in-use"));
+            } else {
+                RED.log.error(RED.log._("server.uncaught-exception"));
+                if (err.stack) {
+                    RED.log.error(err.stack);
+                } else {
+                    RED.log.error(err);
+                }
+            }
+            process.exit(1);
+        });
+        server.listen(settings.uiPort,settings.uiHost,function() {
+            if (settings.httpAdminRoot === false) {
+                RED.log.info(RED.log._("server.admin-ui-disabled"));
+            }
+            settings.serverPort = server.address().port;
+            process.title = 'node-red';
+            RED.log.info(RED.log._("server.now-running", {listenpath:getListenPath()}));
+        });
+    } else {
+        RED.log.info(RED.log._("server.headless-mode"));
+    }
+}).otherwise(function(err) {
+    RED.log.error(RED.log._("server.failed-to-start"));
+    if (err.stack) {
+        RED.log.error(err.stack);
+    } else {
+        RED.log.error(err);
+    }
+});
+
+process.on('uncaughtException',function(err) {
+    util.log('[red] Uncaught Exception:');
+    if (err.stack) {
+        util.log(err.stack);
+    } else {
+        util.log(err);
+    }
+    process.exit(1);
+});

package/index.js

@@ -0,0 +1,185 @@
+const constants = require("./constants");
+const { AdapterFactory } = require("./adapters");
+const { UrlParser } = require("./utils");
+
+/**
+ * Storage module for Node-RED with pluggable database backends.
+ * Encapsulates adapter and settings state within the module closure.
+ */
+var storageModule = (function () {
+  // Private state encapsulated in closure
+  let _settings = null;
+  let _adapter = null;
+  let _collectionNames = null;
+
+  /**
+   * Parse configuration options and extract database connection details
+   * @param {Object} options - Storage module options
+   * @returns {Object} Parsed configuration with dbType, dbUrl, dbName
+   */
+  function parseConfiguration(options) {
+    let dbType, dbUrl, dbName;
+
+    if (options.type) {
+      // New configuration format with explicit type
+      dbType = options.type;
+      dbUrl = options.url;
+      dbName = options.database;
+    } else if (options.mongoUrl) {
+      // Legacy MongoDB configuration for backward compatibility
+      dbType = "mongodb";
+      dbUrl = options.mongoUrl;
+      dbName = options.database;
+    } else if (options.postgresUrl) {
+      // PostgreSQL configuration
+      dbType = "postgres";
+      dbUrl = options.postgresUrl;
+      dbName = options.database;
+    } else {
+      throw new Error(
+        "Database URL is required. Provide 'url' with 'type', or 'mongoUrl'/'postgresUrl'",
+      );
+    }
+
+    if (!dbUrl) {
+      throw new Error("Database URL is required");
+    }
+
+    // Extract database name from URL if not provided
+    if (!dbName) {
+      dbName = UrlParser.extractDatabaseName(dbType, dbUrl);
+    }
+
+    // Standardized interface requires database name for all adapters
+    if (!dbName) {
+      throw new Error(
+        "Database name is required. Provide 'database' in configuration or include it in the connection URL",
+      );
+    }
+
+    return { dbType, dbUrl, dbName };
+  }
+
+  /**
+   * Initialize collection names from configuration
+   * @param {Object} options - Storage module options
+   * @returns {Object} Collection names mapping
+   */
+  function initializeCollectionNames(options) {
+    const collectionNames = Object.assign({}, constants.DefaultCollectionNames);
+    if (options.collectionNames != null) {
+      for (let name of Object.keys(options.collectionNames)) {
+        collectionNames[name] = options.collectionNames[name];
+      }
+    }
+    return collectionNames;
+  }
+
+  return {
+    init: function (settings) {
+      _settings = settings;
+
+      // Validate required options
+      if (_settings.storageModuleOptions == null) {
+        throw new Error("storageModuleOptions is required");
+      }
+
+      const options = _settings.storageModuleOptions;
+
+      // Parse configuration
+      const { dbType, dbUrl, dbName } = parseConfiguration(options);
+
+      // Set up collection names
+      _collectionNames = initializeCollectionNames(options);
+
+      // Create adapter
+      _adapter = AdapterFactory.create(dbType, {
+        url: dbUrl,
+        database: dbName,
+      });
+
+      return _adapter.connect();
+    },
+
+    // Expose collection names for external access
+    get collectionNames() {
+      return _collectionNames;
+    },
+
+    getFlows: function () {
+      return _adapter.findAll(_collectionNames.flows);
+    },
+
+    saveFlows: function (flows) {
+      return _adapter.saveAll(_collectionNames.flows, flows);
+    },
+
+    getCredentials: function () {
+      return _adapter.findAll(_collectionNames.credentials).then((result) => {
+        // Convert array back to object format that Node-RED expects
+        if (Array.isArray(result) && result.length > 0) {
+          return result[0];
+        }
+        return {};
+      });
+    },
+
+    saveCredentials: function (credentials) {
+      // Node-RED passes credentials as an object, convert to array for storage
+      const credentialsArray =
+        credentials && Object.keys(credentials).length > 0 ? [credentials] : [];
+      return _adapter.saveAll(_collectionNames.credentials, credentialsArray);
+    },
+
+    getSettings: function () {
+      return _adapter.findAll(_collectionNames.settings).then((result) => {
+        // Convert array back to object format that Node-RED expects
+        if (Array.isArray(result) && result.length > 0) {
+          return result[0];
+        }
+        return {};
+      });
+    },
+
+    saveSettings: function (settings) {
+      // Node-RED passes settings as an object, convert to array for storage
+      const settingsArray =
+        settings && Object.keys(settings).length > 0 ? [settings] : [];
+      return _adapter.saveAll(_collectionNames.settings, settingsArray);
+    },
+
+    getSessions: function () {
+      return _adapter.findAll(_collectionNames.sessions).then((result) => {
+        // Convert array back to object format that Node-RED expects
+        if (Array.isArray(result) && result.length > 0) {
+          return result[0];
+        }
+        return {};
+      });
+    },
+
+    saveSessions: function (sessions) {
+      // Node-RED passes sessions as an object, convert to array for storage
+      const sessionsArray =
+        sessions && Object.keys(sessions).length > 0 ? [sessions] : [];
+      return _adapter.saveAll(_collectionNames.sessions, sessionsArray);
+    },
+
+    getLibraryEntry: function (type, path) {
+      return _adapter.findOneByPath(type, path);
+    },
+
+    saveLibraryEntry: function (type, path, meta, body) {
+      return _adapter.saveOrUpdateByPath(type, path, meta, body);
+    },
+
+    close: function () {
+      if (_adapter) {
+        return _adapter.close();
+      }
+      return Promise.resolve();
+    },
+  };
+})();
+
+module.exports = storageModule;

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "node-red-contrib-db-storage",
+  "version": "0.2.0",
+  "description": "Node-RED storage plugin with support for MongoDB, PostgreSQL, and other databases",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest --coverage --testPathIgnorePatterns=integration",
+    "test:unit": "jest --coverage --testPathIgnorePatterns=integration",
+    "test:integration": "jest --testMatch='**/*.integration.test.js' --runInBand",
+    "test:integration:mongo": "TEST_DATABASES=mongodb jest --testMatch='**/*.integration.test.js' --runInBand",
+    "test:integration:postgres": "TEST_DATABASES=postgres jest --testMatch='**/*.integration.test.js' --runInBand",
+    "test:all": "npm run test:unit && npm run test:integration",
+    "docker:up": "docker-compose up -d",
+    "docker:down": "docker-compose down",
+    "docker:logs": "docker-compose logs -f"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/srmurali002/node-red-contrib-db-storage.git"
+  },
+  "keywords": [
+    "node-red",
+    "storage",
+    "mongodb",
+    "postgres",
+    "postgresql",
+    "database"
+  ],
+  "author": "srmurali002",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/srmurali002/node-red-contrib-db-storage/issues"
+  },
+  "homepage": "https://github.com/srmurali002/node-red-contrib-db-storage#readme",
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.4.1",
+    "mongodb": "^3.4.1",
+    "mysql2": "^3.15.3"
+  },
+  "optionalDependencies": {
+    "pg": "^8.11.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "peerDependencies": {
+    "pg": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "pg": {
+      "optional": true
+    }
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coverageDirectory": "coverage",
+    "collectCoverageFrom": [
+      "*.js",
+      "adapters/**/*.js",
+      "!jest.config.js"
+    ],
+    "testMatch": [
+      "**/*.test.js"
+    ]
+  }
+}

package/utils/UrlParser.js

@@ -0,0 +1,140 @@
+/**
+ * Utility class for parsing database connection URLs
+ * Extracts database names from various connection URL formats
+ */
+class UrlParser {
+  /**
+   * Extract database name from a connection URL based on database type
+   * @param {string} dbType - The database type (postgres, mysql, sqlite, etc.)
+   * @param {string} url - The connection URL
+   * @returns {string|null} The extracted database name or null if not found
+   */
+  static extractDatabaseName(dbType, url) {
+    if (!dbType || !url) {
+      return null;
+    }
+
+    const dbTypeLower = dbType.toLowerCase();
+
+    // PostgreSQL and MySQL: extract from connection URL
+    // Format: postgresql://user:password@host:port/database or mysql://user:password@host:port/database
+    if (this.isRelationalDatabase(dbTypeLower)) {
+      return this.extractFromConnectionUrl(url);
+    }
+
+    // SQLite: use the filename as database name
+    if (this.isSQLite(dbTypeLower)) {
+      return this.extractFromSQLitePath(url);
+    }
+
+    // MongoDB: extract from connection URL
+    if (this.isMongoDB(dbTypeLower)) {
+      return this.extractFromConnectionUrl(url);
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if the database type is a relational database (PostgreSQL or MySQL)
+   * @param {string} dbType - The database type in lowercase
+   * @returns {boolean}
+   */
+  static isRelationalDatabase(dbType) {
+    return ['postgres', 'postgresql', 'pg', 'mysql', 'mariadb'].includes(dbType);
+  }
+
+  /**
+   * Check if the database type is SQLite
+   * @param {string} dbType - The database type in lowercase
+   * @returns {boolean}
+   */
+  static isSQLite(dbType) {
+    return ['sqlite', 'sqlite3'].includes(dbType);
+  }
+
+  /**
+   * Check if the database type is MongoDB
+   * @param {string} dbType - The database type in lowercase
+   * @returns {boolean}
+   */
+  static isMongoDB(dbType) {
+    return ['mongodb', 'mongo'].includes(dbType);
+  }
+
+  /**
+   * Extract database name from a standard connection URL
+   * @param {string} url - The connection URL
+   * @returns {string|null} The database name or null if not found
+   */
+  static extractFromConnectionUrl(url) {
+    // Parse URL to extract path after host:port
+    // Format: protocol://[user:pass@]host[:port]/database[?params]
+    // We need to find the database name which is in the path after the authority
+
+    // Remove protocol
+    let remaining = url.replace(/^[a-zA-Z]+:\/\//, '');
+
+    // Find the start of the path (first slash after host:port)
+    const pathStart = remaining.indexOf('/');
+    if (pathStart === -1) {
+      return null; // No path, no database
+    }
+
+    // Extract path
+    let path = remaining.substring(pathStart + 1);
+
+    // Remove query parameters
+    const queryStart = path.indexOf('?');
+    if (queryStart !== -1) {
+      path = path.substring(0, queryStart);
+    }
+
+    // The database name is what's left
+    return path || null;
+  }
+
+  /**
+   * Extract database name from SQLite file path
+   * @param {string} url - The SQLite file path or URL
+   * @returns {string} The database name (filename without extension)
+   */
+  static extractFromSQLitePath(url) {
+    let filePath = url;
+
+    // Remove URL prefixes
+    if (filePath.startsWith('sqlite://')) {
+      filePath = filePath.replace('sqlite://', '');
+    } else if (filePath.startsWith('file://')) {
+      filePath = filePath.replace('file://', '');
+    }
+
+    // Handle memory databases
+    if (filePath === ':memory:') {
+      return 'memory';
+    }
+
+    // Extract filename without extension as database name
+    const fileName = filePath.split('/').pop();
+    return fileName.replace(/\.[^/.]+$/, '') || 'sqlite';
+  }
+
+  /**
+   * Normalize SQLite file path by removing URL prefixes
+   * @param {string} url - The SQLite file path or URL
+   * @returns {string} The normalized file path
+   */
+  static normalizeSQLitePath(url) {
+    let filePath = url;
+
+    if (filePath.startsWith('sqlite://')) {
+      filePath = filePath.replace('sqlite://', '');
+    } else if (filePath.startsWith('file://')) {
+      filePath = filePath.replace('file://', '');
+    }
+
+    return filePath;
+  }
+}
+
+module.exports = UrlParser;

package/utils/index.js

@@ -0,0 +1,5 @@
+const UrlParser = require('./UrlParser');
+
+module.exports = {
+  UrlParser
+};