node-red-contrib-questdb 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# node-red-contrib-questdb
+
+Node-RED nodes for QuestDB time-series database.
+
+## Installation
+
+```bash
+npm install node-red-contrib-questdb
+```
+
+## Nodes
+
+### questdb
+
+A node for interacting with QuestDB time-series database.
+
+## License
+
+MIT

package/nodes/mapper.html

@@ -0,0 +1,205 @@
+<script type="text/javascript">
+    RED.nodes.registerType('questdb-mapper', {
+        category: 'questdb',
+        color: '#a23154',
+        defaults: {
+            name: {value: ""},
+            tableName: {value: ""},
+            timestampField: {value: ""},
+            symbolMappings: {value: []},
+            columnMappings: {value: []}
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-exchange",
+        label: function() {
+            return this.name || "Mapper";
+        },
+        paletteLabel: "Mapper",
+        labelStyle: function() {
+            return this.name ? "node_label_italic questdb-white-text" : "questdb-white-text";
+        },
+        oneditprepare: function() {
+            const node = this;
+
+            // Symbol mappings list
+            const symbolList = $("#node-input-symbol-list").css({
+                'min-height': '100px',
+                'min-width': '400px'
+            }).editableList({
+                addItem: function(container, i, data) {
+                    const row = $('<div/>').appendTo(container);
+                    $('<input/>', {type: "text", placeholder: "msg.field", class: "symbol-source"})
+                        .css({width: "45%", marginRight: "5px"})
+                        .val(data.source || "")
+                        .appendTo(row);
+                    $('<span/>').text(" → ").appendTo(row);
+                    $('<input/>', {type: "text", placeholder: "symbol name", class: "symbol-target"})
+                        .css({width: "40%", marginLeft: "5px"})
+                        .val(data.target || "")
+                        .appendTo(row);
+                },
+                removable: true,
+                sortable: true
+            });
+
+            // Column mappings list
+            const columnList = $("#node-input-column-list").css({
+                'min-height': '100px',
+                'min-width': '400px'
+            }).editableList({
+                addItem: function(container, i, data) {
+                    const row = $('<div/>').appendTo(container);
+                    $('<input/>', {type: "text", placeholder: "msg.field", class: "column-source"})
+                        .css({width: "35%", marginRight: "5px"})
+                        .val(data.source || "")
+                        .appendTo(row);
+                    $('<span/>').text(" → ").appendTo(row);
+                    $('<input/>', {type: "text", placeholder: "column name", class: "column-target"})
+                        .css({width: "30%", marginLeft: "5px", marginRight: "5px"})
+                        .val(data.target || "")
+                        .appendTo(row);
+                    const typeSelect = $('<select/>', {class: "column-type"})
+                        .css({width: "20%"})
+                        .appendTo(row);
+                    ['auto', 'float', 'integer', 'string', 'boolean', 'timestamp'].forEach(function(t) {
+                        $('<option/>').val(t).text(t).appendTo(typeSelect);
+                    });
+                    typeSelect.val(data.type || "auto");
+                },
+                removable: true,
+                sortable: true
+            });
+
+            // Load existing mappings
+            if (node.symbolMappings) {
+                node.symbolMappings.forEach(function(m) {
+                    symbolList.editableList('addItem', m);
+                });
+            }
+            if (node.columnMappings) {
+                node.columnMappings.forEach(function(m) {
+                    columnList.editableList('addItem', m);
+                });
+            }
+        },
+        oneditresize: function(size) {
+            // Resize editable lists if needed
+        },
+        oneditsave: function() {
+            const node = this;
+
+            // Save symbol mappings
+            node.symbolMappings = [];
+            $("#node-input-symbol-list").editableList('items').each(function() {
+                const source = $(this).find(".symbol-source").val().trim();
+                const target = $(this).find(".symbol-target").val().trim();
+                if (source && target) {
+                    node.symbolMappings.push({source: source, target: target});
+                }
+            });
+
+            // Save column mappings
+            node.columnMappings = [];
+            $("#node-input-column-list").editableList('items').each(function() {
+                const source = $(this).find(".column-source").val().trim();
+                const target = $(this).find(".column-target").val().trim();
+                const type = $(this).find(".column-type").val();
+                if (source && target) {
+                    node.columnMappings.push({source: source, target: target, type: type});
+                }
+            });
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="questdb-mapper">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-tableName"><i class="fa fa-table"></i> Table Name</label>
+        <input type="text" id="node-input-tableName" placeholder="Leave empty to use msg.topic">
+    </div>
+    <div class="form-row">
+        <label for="node-input-timestampField"><i class="fa fa-clock-o"></i> Timestamp Field</label>
+        <input type="text" id="node-input-timestampField" placeholder="e.g. payload.timestamp">
+    </div>
+    <div class="form-row">
+        <label style="width:100%;"><i class="fa fa-bookmark"></i> Symbol Mappings (indexed tags)</label>
+        <ol id="node-input-symbol-list"></ol>
+    </div>
+    <div class="form-row">
+        <label style="width:100%;"><i class="fa fa-columns"></i> Column Mappings (values)</label>
+        <ol id="node-input-column-list"></ol>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="questdb-mapper">
+    <p>Maps message fields to QuestDB ILP structure for use with the Write node.</p>
+
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>Table Name</dt>
+        <dd>Target table name. If empty, uses <code>msg.topic</code></dd>
+        <dt>Timestamp Field</dt>
+        <dd>Path to timestamp field (e.g. <code>payload.ts</code>)</dd>
+        <dt>Symbol Mappings</dt>
+        <dd>Map msg fields to QuestDB symbols (indexed string columns)</dd>
+        <dt>Column Mappings</dt>
+        <dd>Map msg fields to QuestDB columns with type conversion</dd>
+    </dl>
+
+    <h3>Field Path Syntax</h3>
+    <p>Use dot notation: <code>payload.sensor.value</code></p>
+    <p>Array access: <code>payload.readings[0]</code></p>
+
+    <h3>Output</h3>
+    <p>Produces a message ready for the QuestDB Write node:</p>
+    <pre>{
+  topic: "table_name",
+  payload: {
+    symbols: { ... },
+    columns: { ... },
+    timestamp: ...
+  }
+}</pre>
+
+    <h3>Example</h3>
+    <p>Input message:</p>
+    <pre>{
+  topic: "sensors",
+  payload: {
+    device: "sensor1",
+    temp: 23.5,
+    ts: 1699999999000
+  }
+}</pre>
+    <p>With mappings:</p>
+    <ul>
+        <li>Symbol: <code>payload.device</code> → <code>device_id</code></li>
+        <li>Column: <code>payload.temp</code> → <code>temperature</code> (float)</li>
+        <li>Timestamp: <code>payload.ts</code></li>
+    </ul>
+    <p>Output:</p>
+    <pre>{
+  topic: "sensors",
+  payload: {
+    symbols: { device_id: "sensor1" },
+    columns: { temperature: 23.5 },
+    timestamp: 1699999999000
+  }
+}</pre>
+</script>
+
+<style>
+    /* White text on flow canvas */
+    .questdb-white-text {
+        fill: #ffffff !important;
+    }
+    /* White text in palette */
+    .red-ui-palette-node[data-palette-type="questdb-mapper"] .red-ui-palette-label {
+        color: #ffffff !important;
+    }
+</style>

package/nodes/mapper.js

@@ -0,0 +1,113 @@
+module.exports = function(RED) {
+    function QuestDBMapperNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Configuration from node properties
+        node.tableName = config.tableName;
+        node.timestampField = config.timestampField;
+        node.symbolMappings = config.symbolMappings || [];
+        node.columnMappings = config.columnMappings || [];
+
+        node.on('input', function(msg, send, done) {
+            try {
+                const output = {
+                    topic: node.tableName || msg.topic,
+                    payload: {
+                        symbols: {},
+                        columns: {}
+                    }
+                };
+
+                // Map timestamp
+                if (node.timestampField) {
+                    const tsValue = getNestedValue(msg, node.timestampField);
+                    if (tsValue !== undefined) {
+                        output.payload.timestamp = tsValue;
+                    }
+                }
+
+                // Map symbols
+                for (const mapping of node.symbolMappings) {
+                    if (mapping.source && mapping.target) {
+                        const value = getNestedValue(msg, mapping.source);
+                        if (value !== undefined && value !== null) {
+                            output.payload.symbols[mapping.target] = String(value);
+                        }
+                    }
+                }
+
+                // Map columns
+                for (const mapping of node.columnMappings) {
+                    if (mapping.source && mapping.target) {
+                        let value = getNestedValue(msg, mapping.source);
+                        if (value !== undefined && value !== null) {
+                            // Type conversion based on mapping type
+                            switch (mapping.type) {
+                                case 'float':
+                                    value = parseFloat(value);
+                                    if (isNaN(value)) continue;
+                                    break;
+                                case 'integer':
+                                    value = parseInt(value, 10);
+                                    if (isNaN(value)) continue;
+                                    break;
+                                case 'boolean':
+                                    value = Boolean(value);
+                                    break;
+                                case 'string':
+                                    value = String(value);
+                                    break;
+                                case 'timestamp':
+                                    if (typeof value === 'string') {
+                                        value = new Date(value);
+                                    } else if (typeof value === 'number') {
+                                        value = new Date(value);
+                                    }
+                                    break;
+                                // 'auto' - keep original type
+                            }
+                            output.payload.columns[mapping.target] = value;
+                        }
+                    }
+                }
+
+                node.status({fill:"green", shape:"dot", text:`mapped: ${output.topic}`});
+                send(output);
+                done();
+
+            } catch (err) {
+                node.status({fill:"red", shape:"ring", text:"error"});
+                done(err);
+            }
+        });
+
+        // Helper function to get nested property value
+        function getNestedValue(obj, path) {
+            // Strip 'msg.' prefix if present since we're already working with msg object
+            if (path.startsWith('msg.')) {
+                path = path.substring(4);
+            }
+            const parts = path.split('.');
+            let current = obj;
+            for (const part of parts) {
+                if (current === undefined || current === null) {
+                    return undefined;
+                }
+                // Handle array notation like payload[0]
+                const match = part.match(/^(\w+)\[(\d+)\]$/);
+                if (match) {
+                    current = current[match[1]];
+                    if (Array.isArray(current)) {
+                        current = current[parseInt(match[2], 10)];
+                    }
+                } else {
+                    current = current[part];
+                }
+            }
+            return current;
+        }
+    }
+
+    RED.nodes.registerType("questdb-mapper", QuestDBMapperNode);
+};

package/nodes/write.html

@@ -0,0 +1,289 @@
+<script type="text/javascript">
+    // Configuration node
+    RED.nodes.registerType('questdb-config',{
+        category: 'config',
+        defaults: {
+            name: {value:""},
+            protocol: {value:"http"},
+            host: {value:"localhost", required:true},
+            port: {value:9000, required:true, validate:RED.validators.number()},
+            tlsVerify: {value:true},
+            tlsCa: {value:""},
+            autoFlush: {value:true},
+            autoFlushRows: {value:75000, validate:RED.validators.number()},
+            autoFlushInterval: {value:1000, validate:RED.validators.number()},
+            requestTimeout: {value:10000, validate:RED.validators.number()},
+            retryTimeout: {value:10000, validate:RED.validators.number()},
+            initBufSize: {value:65536, validate:RED.validators.number()},
+            maxBufSize: {value:104857600, validate:RED.validators.number()},
+            useAuth: {value:false},
+            authType: {value:"basic"}
+        },
+        credentials: {
+            username: {type:"text"},
+            password: {type:"password"},
+            token: {type:"password"}
+        },
+        label: function() {
+            return this.name || `${this.host}:${this.port}`;
+        },
+        oneditprepare: function() {
+            var tabs = RED.tabs.create({
+                id: "questdb-config-tabs",
+                onchange: function(tab) {
+                    $("#questdb-config-tabs-content").children().hide();
+                    $("#" + tab.id).show();
+                }
+            });
+            tabs.addTab({
+                id: "questdb-tab-connection",
+                label: "Connection"
+            });
+            tabs.addTab({
+                id: "questdb-tab-security",
+                label: "Security"
+            });
+            tabs.addTab({
+                id: "questdb-tab-advanced",
+                label: "Advanced"
+            });
+
+            // Show/hide TLS options based on protocol
+            $("#node-config-input-protocol").on("change", function() {
+                var proto = $(this).val();
+                if (proto === "https" || proto === "tcps") {
+                    $(".tls-row").show();
+                } else {
+                    $(".tls-row").hide();
+                }
+                // Update default port
+                if (proto === "tcp" || proto === "tcps") {
+                    if ($("#node-config-input-port").val() === "9000") {
+                        $("#node-config-input-port").val("9009");
+                    }
+                } else {
+                    if ($("#node-config-input-port").val() === "9009") {
+                        $("#node-config-input-port").val("9000");
+                    }
+                }
+            });
+            $("#node-config-input-protocol").trigger("change");
+
+            // Show/hide auth options
+            $("#node-config-input-useAuth").on("change", function() {
+                if ($(this).is(":checked")) {
+                    $(".auth-type-row").show();
+                    $("#node-config-input-authType").trigger("change");
+                } else {
+                    $(".auth-type-row").hide();
+                    $(".auth-row").hide();
+                }
+            });
+            $("#node-config-input-useAuth").trigger("change");
+
+            // Show/hide auth fields based on auth type
+            $("#node-config-input-authType").on("change", function() {
+                var authType = $(this).val();
+                if (authType === "basic") {
+                    $(".basic-auth-row").show();
+                    $(".token-auth-row").hide();
+                } else {
+                    $(".basic-auth-row").hide();
+                    $(".token-auth-row").show();
+                }
+            });
+            $("#node-config-input-authType").trigger("change");
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="questdb-config">
+    <div class="form-row">
+        <ul style="min-width: 450px; margin-bottom: 20px;" id="questdb-config-tabs"></ul>
+    </div>
+    <div id="questdb-config-tabs-content">
+        <div id="questdb-tab-connection" style="display:block;">
+            <div class="form-row">
+                <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+                <input type="text" id="node-config-input-name" placeholder="QuestDB Server">
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-protocol"><i class="fa fa-exchange"></i> Protocol</label>
+                <select id="node-config-input-protocol" style="width:70%;">
+                    <option value="http">HTTP</option>
+                    <option value="https">HTTPS (TLS)</option>
+                    <option value="tcp">TCP</option>
+                    <option value="tcps">TCPS (TLS)</option>
+                </select>
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-host"><i class="fa fa-server"></i> Host</label>
+                <input type="text" id="node-config-input-host" placeholder="localhost or IP address">
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-port"><i class="fa fa-plug"></i> Port</label>
+                <input type="text" id="node-config-input-port" placeholder="9000">
+            </div>
+            <div class="form-row tls-row">
+                <label for="node-config-input-tlsVerify"><i class="fa fa-certificate"></i> Verify TLS</label>
+                <input type="checkbox" id="node-config-input-tlsVerify" style="display:inline-block; width:auto; vertical-align:baseline;" checked>
+                <span style="margin-left:8px;">Verify server certificate</span>
+            </div>
+            <div class="form-row tls-row">
+                <label for="node-config-input-tlsCa"><i class="fa fa-file-text-o"></i> CA Cert Path</label>
+                <input type="text" id="node-config-input-tlsCa" placeholder="Path to CA certificate (PEM)">
+            </div>
+        </div>
+        <div id="questdb-tab-security" style="display:none;">
+            <div class="form-row">
+                <label for="node-config-input-useAuth"><i class="fa fa-lock"></i> Enable Auth</label>
+                <input type="checkbox" id="node-config-input-useAuth" style="display:inline-block; width:auto; vertical-align:baseline;">
+                <span style="margin-left:8px;">Enable authentication</span>
+            </div>
+            <div class="form-row auth-type-row">
+                <label for="node-config-input-authType"><i class="fa fa-id-card"></i> Auth Type</label>
+                <select id="node-config-input-authType" style="width:70%;">
+                    <option value="basic">Username / Password</option>
+                    <option value="token">Bearer Token</option>
+                </select>
+            </div>
+            <div class="form-row auth-row basic-auth-row">
+                <label for="node-config-input-username"><i class="fa fa-user"></i> Username</label>
+                <input type="text" id="node-config-input-username" placeholder="Username">
+            </div>
+            <div class="form-row auth-row basic-auth-row">
+                <label for="node-config-input-password"><i class="fa fa-key"></i> Password</label>
+                <input type="password" id="node-config-input-password" placeholder="Password">
+            </div>
+            <div class="form-row auth-row token-auth-row">
+                <label for="node-config-input-token"><i class="fa fa-ticket"></i> Token</label>
+                <input type="password" id="node-config-input-token" placeholder="Bearer token">
+            </div>
+        </div>
+        <div id="questdb-tab-advanced" style="display:none;">
+            <div class="form-row">
+                <label for="node-config-input-autoFlush"><i class="fa fa-refresh"></i> Auto Flush</label>
+                <input type="checkbox" id="node-config-input-autoFlush" style="display:inline-block; width:auto; vertical-align:baseline;" checked>
+                <span style="margin-left:8px;">Enable automatic flushing</span>
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-autoFlushRows"><i class="fa fa-bars"></i> Flush Rows</label>
+                <input type="text" id="node-config-input-autoFlushRows" placeholder="75000">
+                <span style="margin-left:8px; font-size:0.9em; color:#888;">Rows before auto-flush</span>
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-autoFlushInterval"><i class="fa fa-clock-o"></i> Flush Interval</label>
+                <input type="text" id="node-config-input-autoFlushInterval" placeholder="1000">
+                <span style="margin-left:8px; font-size:0.9em; color:#888;">ms</span>
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-requestTimeout"><i class="fa fa-hourglass"></i> Request Timeout</label>
+                <input type="text" id="node-config-input-requestTimeout" placeholder="10000">
+                <span style="margin-left:8px; font-size:0.9em; color:#888;">ms</span>
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-retryTimeout"><i class="fa fa-repeat"></i> Retry Timeout</label>
+                <input type="text" id="node-config-input-retryTimeout" placeholder="10000">
+                <span style="margin-left:8px; font-size:0.9em; color:#888;">ms</span>
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-initBufSize"><i class="fa fa-database"></i> Init Buffer</label>
+                <input type="text" id="node-config-input-initBufSize" placeholder="65536">
+                <span style="margin-left:8px; font-size:0.9em; color:#888;">bytes (64 KiB)</span>
+            </div>
+            <div class="form-row">
+                <label for="node-config-input-maxBufSize"><i class="fa fa-database"></i> Max Buffer</label>
+                <input type="text" id="node-config-input-maxBufSize" placeholder="104857600">
+                <span style="margin-left:8px; font-size:0.9em; color:#888;">bytes (100 MiB)</span>
+            </div>
+        </div>
+    </div>
+</script>
+
+<script type="text/javascript">
+    // Main QuestDB node
+    RED.nodes.registerType('questdb',{
+        category: 'questdb',
+        color: '#a23154',
+        defaults: {
+            name: {value:""},
+            questdb: {value:"", type:"questdb-config", required:true},
+            autoFlush: {value:true},
+            flushInterval: {value:1000, validate:RED.validators.number()}
+        },
+        inputs:1,
+        outputs:1,
+        icon: "font-awesome/fa-database",
+        label: function() {
+            return this.name || "Write";
+        },
+        paletteLabel: "Write",
+        labelStyle: function() {
+            return (this.name ? "node_label_italic" : "") + " questdb-white-text";
+        }
+    });
+</script>
+
+<style>
+    /* White text on flow canvas */
+    .questdb-white-text {
+        fill: #ffffff !important;
+    }
+    /* White text in palette */
+    .red-ui-palette-node[data-palette-type="questdb"] .red-ui-palette-label {
+        color: #ffffff !important;
+    }
+</style>
+
+<script type="text/html" data-template-name="questdb">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-questdb"><i class="fa fa-server"></i> Server</label>
+        <input type="text" id="node-input-questdb" placeholder="QuestDB Server">
+    </div>
+    <div class="form-row">
+        <label for="node-input-autoFlush"><i class="fa fa-refresh"></i> Auto Flush</label>
+        <input type="checkbox" id="node-input-autoFlush" style="display:inline-block; width:auto; vertical-align:baseline;">
+    </div>
+    <div class="form-row">
+        <label for="node-input-flushInterval"><i class="fa fa-clock-o"></i> Flush Interval (ms)</label>
+        <input type="text" id="node-input-flushInterval" placeholder="1000">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="questdb">
+    <p>Writes data to QuestDB using ILP protocol.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>topic <span class="property-type">string</span></dt>
+        <dd>Table name to write to (required)</dd>
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd>Data to write:
+            <ul>
+                <li><code>symbols</code> - Tag columns (indexed)</li>
+                <li><code>columns</code> - Value columns</li>
+                <li><code>timestamp</code> - Optional (Date, number, or string)</li>
+            </ul>
+        </dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd><code>{ success: true/false, table: "name" }</code></dd>
+    </dl>
+
+    <h3>Example</h3>
+    <pre>{
+  topic: "history_float",
+  payload: {
+    symbols: { tag_name: "temp1" },
+    columns: { value: 23.5 },
+    timestamp: new Date()
+  }
+}</pre>
+</script>

package/nodes/write.js

@@ -0,0 +1,403 @@
+module.exports = function(RED) {
+    const { Sender } = require('@questdb/nodejs-client');
+
+    // Shared connection pool for config nodes
+    const connectionPool = new Map();
+
+    // Build connection string from config
+    function buildConnectionString(configNode) {
+        const protocol = configNode.protocol || 'http';
+        let connStr = `${protocol}::addr=${configNode.host}:${configNode.port};`;
+
+        // Authentication
+        if (configNode.useAuth) {
+            if (configNode.authType === 'token' && configNode.token) {
+                connStr += `token=${configNode.token};`;
+            } else if (configNode.username && configNode.password) {
+                connStr += `username=${configNode.username};password=${configNode.password};`;
+            }
+        }
+
+        // TLS options (for https/tcps)
+        if (protocol === 'https' || protocol === 'tcps') {
+            if (!configNode.tlsVerify) {
+                connStr += `tls_verify=unsafe_off;`;
+            }
+            if (configNode.tlsCa) {
+                connStr += `tls_ca=${configNode.tlsCa};`;
+            }
+        }
+
+        // Auto-flush options
+        if (configNode.autoFlush === false) {
+            connStr += `auto_flush=off;`;
+        } else {
+            if (configNode.autoFlushRows) {
+                connStr += `auto_flush_rows=${configNode.autoFlushRows};`;
+            }
+            if (configNode.autoFlushInterval) {
+                connStr += `auto_flush_interval=${configNode.autoFlushInterval};`;
+            }
+        }
+
+        // Buffer options
+        if (configNode.initBufSize) {
+            connStr += `init_buf_size=${configNode.initBufSize};`;
+        }
+        if (configNode.maxBufSize) {
+            connStr += `max_buf_size=${configNode.maxBufSize};`;
+        }
+
+        // HTTP options
+        if (protocol === 'http' || protocol === 'https') {
+            if (configNode.requestTimeout) {
+                connStr += `request_timeout=${configNode.requestTimeout};`;
+            }
+            if (configNode.retryTimeout) {
+                connStr += `retry_timeout=${configNode.retryTimeout};`;
+            }
+        }
+
+        return connStr;
+    }
+
+    // Configuration node for QuestDB connection
+    function QuestDBConfigNode(config) {
+        RED.nodes.createNode(this, config);
+        const configNode = this;
+
+        // Connection settings
+        configNode.protocol = config.protocol || 'http';
+        configNode.host = config.host;
+        configNode.port = parseInt(config.port) || (configNode.protocol.startsWith('tcp') ? 9009 : 9000);
+        configNode.name = config.name;
+
+        // TLS settings
+        configNode.tlsVerify = config.tlsVerify !== false;
+        configNode.tlsCa = config.tlsCa || '';
+
+        // Auth settings
+        configNode.useAuth = config.useAuth || false;
+        configNode.authType = config.authType || 'basic';
+        configNode.username = this.credentials ? this.credentials.username : '';
+        configNode.password = this.credentials ? this.credentials.password : '';
+        configNode.token = this.credentials ? this.credentials.token : '';
+
+        // Auto-flush settings
+        configNode.autoFlush = config.autoFlush !== false;
+        configNode.autoFlushRows = parseInt(config.autoFlushRows) || 75000;
+        configNode.autoFlushInterval = parseInt(config.autoFlushInterval) || 1000;
+
+        // Buffer settings
+        configNode.initBufSize = parseInt(config.initBufSize) || 65536;
+        configNode.maxBufSize = parseInt(config.maxBufSize) || 104857600;
+
+        // HTTP settings
+        configNode.requestTimeout = parseInt(config.requestTimeout) || 10000;
+        configNode.retryTimeout = parseInt(config.retryTimeout) || 10000;
+
+        const connectionKey = `${configNode.protocol}://${configNode.host}:${configNode.port}`;
+
+        // Initialize shared connection if not exists
+        if (!connectionPool.has(connectionKey)) {
+            const connectionState = {
+                sender: null,
+                connected: false,
+                connecting: false,
+                users: 0,
+                reconnectTimer: null
+            };
+
+            connectionState.connect = async function() {
+                if (connectionState.connecting || connectionState.connected) {
+                    return;
+                }
+
+                connectionState.connecting = true;
+
+                try {
+                    // Validate configuration
+                    if (!configNode.host || isNaN(configNode.port)) {
+                        throw new Error(`Invalid configuration: host=${configNode.host}, port=${configNode.port}`);
+                    }
+
+                    const connStr = buildConnectionString(configNode);
+                    RED.log.info(`[QuestDB] Connecting with: ${connStr.replace(/password=[^;]+/, 'password=***').replace(/token=[^;]+/, 'token=***')}`);
+
+                    connectionState.sender = Sender.fromConfig(connStr);
+                    connectionState.connected = true;
+                    connectionState.connecting = false;
+
+                    RED.log.info(`[QuestDB] Connected to ${configNode.protocol}://${configNode.host}:${configNode.port}`);
+                } catch (err) {
+                    connectionState.connected = false;
+                    connectionState.connecting = false;
+                    RED.log.error(`[QuestDB] Failed to connect to ${configNode.host}:${configNode.port}: ${err.message}`);
+
+                    // Schedule reconnection
+                    if (!connectionState.reconnectTimer) {
+                        connectionState.reconnectTimer = setTimeout(() => {
+                            connectionState.reconnectTimer = null;
+                            if (connectionState.users > 0) {
+                                connectionState.connect();
+                            }
+                        }, 5000); // Retry in 5 seconds
+                    }
+                }
+            };
+            
+            connectionState.disconnect = async function() {
+                if (connectionState.reconnectTimer) {
+                    clearTimeout(connectionState.reconnectTimer);
+                    connectionState.reconnectTimer = null;
+                }
+                
+                if (connectionState.sender) {
+                    try {
+                        await connectionState.sender.flush();
+                        await connectionState.sender.close();
+                        RED.log.info(`[QuestDB] Disconnected from ${configNode.host}:${configNode.port}`);
+                    } catch (err) {
+                        RED.log.error(`[QuestDB] Error closing connection: ${err.message}`);
+                    }
+                    connectionState.sender = null;
+                }
+                connectionState.connected = false;
+            };
+            
+            connectionPool.set(connectionKey, connectionState);
+        }
+        
+        configNode.getConnection = function() {
+            return connectionPool.get(connectionKey);
+        };
+        
+        configNode.on('close', async function(done) {
+            const conn = connectionPool.get(connectionKey);
+            if (conn) {
+                conn.users--;
+                if (conn.users <= 0) {
+                    await conn.disconnect();
+                    connectionPool.delete(connectionKey);
+                }
+            }
+            done();
+        });
+    }
+    RED.nodes.registerType("questdb-config", QuestDBConfigNode, {
+        credentials: {
+            username: {type: "text"},
+            password: {type: "password"},
+            token: {type: "password"}
+        }
+    });
+
+    // Main QuestDB node
+    function QuestDBNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Get configuration from config node
+        node.questdbConfig = RED.nodes.getNode(config.questdb);
+        
+        if (!node.questdbConfig) {
+            node.error("QuestDB configuration not set");
+            node.status({fill:"red", shape:"ring", text:"no config"});
+            return;
+        }
+        
+        // Configuration from the node properties
+        node.autoFlush = config.autoFlush !== false; // default true
+        node.flushInterval = config.flushInterval || 1000;
+        
+        // Get shared connection
+        const connection = node.questdbConfig.getConnection();
+        if (!connection) {
+            node.error("Failed to get connection from config");
+            node.status({fill:"red", shape:"ring", text:"no connection"});
+            return;
+        }
+        
+        connection.users++;
+        
+        // Connect if not already connected
+        if (!connection.connected && !connection.connecting) {
+            connection.connect();
+        }
+        
+        // Update status based on connection state
+        function updateStatus() {
+            if (connection.connected) {
+                node.status({fill:"green", shape:"dot", text:"connected"});
+            } else if (connection.connecting) {
+                node.status({fill:"yellow", shape:"ring", text:"connecting"});
+            } else {
+                node.status({fill:"red", shape:"ring", text:"disconnected"});
+            }
+        }
+        
+        updateStatus();
+        
+        // Periodic status check
+        const statusInterval = setInterval(updateStatus, 2000);
+
+        node.on('input', async function(msg) {
+            // Auto-reconnect if disconnected
+            if (!connection.connected && !connection.connecting) {
+                connection.connect();
+                node.error("Not connected to QuestDB, reconnecting...", msg);
+                updateStatus();
+                return;
+            }
+
+            if (!connection.connected || !connection.sender) {
+                node.error("Not connected to QuestDB", msg);
+                updateStatus();
+                return;
+            }
+
+            // Validate message
+            const tableName = msg.topic;
+            if (!tableName) {
+                node.error("Topic (table name) not specified", msg);
+                node.status({fill:"red", shape:"ring", text:"no topic"});
+                return;
+            }
+
+            const payload = msg.payload;
+            if (payload === undefined || payload === null) {
+                node.error("Payload is empty", msg);
+                node.status({fill:"red", shape:"ring", text:"no payload"});
+                return;
+            }
+
+            try {
+                connection.sender.table(tableName);
+
+                // Check if simple format (msg.topic + numeric payload)
+                if (typeof payload === 'number' || (typeof payload === 'string' && !isNaN(parseFloat(payload)))) {
+                    // Simple format: use msg.topic as tag, payload as value
+                    var tag = msg.topic || 'default';
+                    var value = typeof payload === 'number' ? payload : parseFloat(payload);
+                    connection.sender.symbol('tag_name', tag);
+                    connection.sender.floatColumn('value', value);
+
+                    // Handle timestamp
+                    if (msg.timestamp) {
+                        var ts = typeof msg.timestamp === 'number' ? msg.timestamp : Date.now();
+                        connection.sender.at(BigInt(ts) * 1000n);
+                    } else {
+                        connection.sender.atNow();
+                    }
+                } else {
+                    // QuestDB format: payload.symbols + payload.columns
+                    if (payload.symbols && typeof payload.symbols === 'object') {
+                        for (const [key, value] of Object.entries(payload.symbols)) {
+                            if (value === null || value === undefined) continue;
+                            connection.sender.symbol(String(key), String(value));
+                        }
+                    }
+
+                    if (payload.columns && typeof payload.columns === 'object') {
+                        for (const [key, value] of Object.entries(payload.columns)) {
+                            if (value === null || value === undefined) continue;
+                            if (typeof value === 'number') {
+                                if (!isFinite(value)) {
+                                    node.warn(`Skipping non-finite number for column '${key}'`);
+                                    continue;
+                                }
+                                connection.sender.floatColumn(key, value);
+                            } else if (typeof value === 'boolean') {
+                                connection.sender.booleanColumn(key, value);
+                            } else if (typeof value === 'string') {
+                                // Check if it's an ISO date string
+                                if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+                                    const dateValue = new Date(value);
+                                    if (!isNaN(dateValue.getTime())) {
+                                        // Convert to microseconds for QuestDB
+                                        const microSeconds = BigInt(dateValue.getTime()) * 1000n;
+                                        connection.sender.timestampColumn(key, microSeconds);
+                                    } else {
+                                        connection.sender.stringColumn(key, value);
+                                    }
+                                } else {
+                                    connection.sender.stringColumn(key, value);
+                                }
+                            } else if (value instanceof Date) {
+                                // Convert to microseconds for QuestDB
+                                const microSeconds = BigInt(value.getTime()) * 1000n;
+                                connection.sender.timestampColumn(key, microSeconds);
+                            } else {
+                                node.warn(`Skipping unsupported type '${typeof value}' for column '${key}'`);
+                            }
+                        }
+                    } else if (!payload.symbols) {
+                        node.error("Payload must have 'symbols' and/or 'columns' properties, or be a number", msg);
+                        node.status({fill:"red", shape:"ring", text:"bad format"});
+                        return;
+                    }
+
+                    if (payload.timestamp) {
+                        let timestampMicros;
+                        if (payload.timestamp instanceof Date) {
+                            timestampMicros = BigInt(payload.timestamp.getTime()) * 1000n;
+                        } else if (typeof payload.timestamp === 'number') {
+                            timestampMicros = BigInt(payload.timestamp) * 1000n;
+                        } else if (typeof payload.timestamp === 'bigint') {
+                            timestampMicros = payload.timestamp;
+                        } else if (typeof payload.timestamp === 'string') {
+                            const parsed = Date.parse(payload.timestamp);
+                            if (isNaN(parsed)) {
+                                node.error(`Invalid timestamp string: ${payload.timestamp}`);
+                                connection.sender.atNow(); // Complete the row to avoid buffer corruption
+                                return;
+                            }
+                            timestampMicros = BigInt(parsed) * 1000n;
+                        } else {
+                            node.error(`Invalid timestamp type: ${typeof payload.timestamp}`);
+                            connection.sender.atNow(); // Complete the row to avoid buffer corruption
+                            return;
+                        }
+                        connection.sender.at(timestampMicros);
+                    } else {
+                        connection.sender.atNow();
+                    }
+                }
+
+                if (node.autoFlush) {
+                    await connection.sender.flush();
+                }
+
+                node.status({fill:"green", shape:"dot", text:`sent: ${tableName}`});
+                msg.payload = { success: true, table: tableName };
+                node.send(msg);
+
+            } catch (err) {
+                const errMsg = err.message || String(err);
+
+                node.warn(`QuestDB write failed: ${errMsg}`);
+                node.status({fill:"yellow", shape:"ring", text:"write failed"});
+
+                // Recreate sender to clear bad state
+                try {
+                    const connStr = buildConnectionString(node.questdbConfig);
+                    connection.sender = Sender.fromConfig(connStr);
+                } catch (e) {
+                    connection.connected = false;
+                    connection.connect();
+                }
+
+                msg.payload = { success: false, error: errMsg };
+                node.send(msg);
+            }
+        });
+
+        node.on('close', function(done) {
+            clearInterval(statusInterval);
+            connection.users--;
+            done();
+        });
+    }
+
+    RED.nodes.registerType("questdb", QuestDBNode);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "node-red-contrib-questdb",
+  "version": "0.1.0",
+  "description": "Node-RED nodes for QuestDB time-series database",
+  "keywords": [
+    "node-red",
+    "questdb",
+    "time-series",
+    "database"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "node-red": {
+    "version": ">=2.0.0",
+    "nodes": {
+      "questdb-write": "nodes/write.js",
+      "questdb-mapper": "nodes/mapper.js"
+    }
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "scripts": {
+    "prepublishOnly": "npm test --if-present",
+    "publish:dry": "npm publish --dry-run"
+  },
+  "dependencies": {
+    "@questdb/nodejs-client": "^3.0.0"
+  }
+}