node-red-contrib-prib-functions 0.23.2 → 0.26.0

package/test-runner.js

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+
+// Simple unit test for logistic regression node
+const assert = require('assert');
+const LogisticRegression = require('logisticegression');
+
+// counters used by both runners
+let testsPassed = 0;
+let testsFailed = 0;
+
+// If the CLI includes the word 'transform' proceed to run the
+// transformation node tests rather than the logistic regression
+// suite.  This avoids pulling mocha back in while still exercising
+// the existing mocha-based files under test/transform*.js.
+if (process.argv.includes('transform')) {
+    runTransformTests();
+    return;
+}
+
+// If the CLI includes 'dataanalysis' run dataAnalysis tests
+if (process.argv.includes('dataanalysis')) {
+    runDataAnalysisTests();
+    return;
+}
+
+// If the CLI includes 'columnar' run the columnar-format tests
+if (process.argv.includes('columnar')) {
+    runColumnarTests();
+    return;
+}
+
+
+function test(description, fn) {
+    try {
+        fn();
+        console.log(`✓ PASS: ${description}`);
+        testsPassed++;
+    } catch (err) {
+        console.error(`✗ FAIL: ${description}`);
+        console.error(`  Error: ${err.message}`);
+        testsFailed++;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// transform test emulation
+// ---------------------------------------------------------------------------
+function callMaybeAsync(fn) {
+    return new Promise((resolve, reject) => {
+        try {
+            if (fn.length >= 1) {
+                fn(err => (err ? reject(err) : resolve()));
+            } else {
+                Promise.resolve(fn()).then(resolve, reject);
+            }
+        } catch (err) {
+            reject(err);
+        }
+    });
+}
+
+async function runTransformTests() {
+    const path = require('path');
+    const fs = require('fs');
+
+    let beforeEachFns = [];
+    let afterEachFns = [];
+    let tests = [];
+    let currentDescribe = '';
+
+    global.describe = function(desc, fn) {
+        currentDescribe = desc;
+        fn();
+    };
+    global.beforeEach = function(fn) {
+        beforeEachFns.push(fn);
+    };
+    global.afterEach = function(fn) {
+        afterEachFns.push(fn);
+    };
+    global.it = function(desc, fn) {
+        const full = currentDescribe ? `${currentDescribe} ${desc}` : desc;
+        tests.push({desc: full, fn});
+        return { timeout: () => {} };
+    };
+
+    console.log("Transform Node Tests\n" + "=".repeat(60));
+
+    const dir = path.join(__dirname, 'test');
+    const files = fs.readdirSync(dir).filter(f => /^transform.*\.js$/.test(f));
+    files.forEach(f => require(path.join(dir, f)));
+
+    for (const t of tests) {
+        for (const bf of beforeEachFns) await callMaybeAsync(bf);
+        try {
+            await callMaybeAsync(t.fn);
+            console.log(`✓ PASS: ${t.desc}`);
+            testsPassed++;
+        } catch (err) {
+            console.error(`✗ FAIL: ${t.desc}`);
+            console.error(`  Error: ${err.message}`);
+            testsFailed++;
+        }
+        for (const af of afterEachFns) {
+            try {
+                await callMaybeAsync(af);
+            } catch (err) {
+                // ignore server-not-running errors which happen when
+                // cleanup double-closes the Node-RED test helper server.
+                if (err && err.code === 'ERR_SERVER_NOT_RUNNING') {
+                    // no-op
+                } else {
+                    throw err;
+                }
+            }
+        }
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`Tests passed: ${testsPassed}`);
+    console.log(`Tests failed: ${testsFailed}`);
+    console.log('='.repeat(60));
+    process.exit(testsFailed > 0 ? 1 : 0);
+}
+
+// ---------------------------------------------------------------------------
+// dataanalysis test emulation
+// ---------------------------------------------------------------------------
+async function runDataAnalysisTests() {
+    const path = require('path');
+    const fs = require('fs');
+
+    let beforeEachFns = [];
+    let afterEachFns = [];
+    let tests = [];
+    let currentDescribe = '';
+
+    global.describe = function(desc, fn) {
+        currentDescribe = desc;
+        fn();
+    };
+    global.beforeEach = function(fn) {
+        beforeEachFns.push(fn);
+    };
+    global.afterEach = function(fn) {
+        afterEachFns.push(fn);
+    };
+    global.it = function(desc, fn) {
+        const full = currentDescribe ? `${currentDescribe} ${desc}` : desc;
+        tests.push({desc: full, fn});
+        return { timeout: () => {} };
+    };
+
+    console.log("Data Analysis Extension Tests\n" + "=".repeat(60));
+
+    const dir = path.join(__dirname, 'test');
+    const files = fs.readdirSync(dir).filter(f => /^dataAnalysisE.*\.js$/.test(f));
+    files.forEach(f => require(path.join(dir, f)));
+
+    for (const t of tests) {
+        for (const bf of beforeEachFns) await callMaybeAsync(bf);
+        try {
+            await callMaybeAsync(t.fn);
+            console.log(`✓ PASS: ${t.desc}`);
+            testsPassed++;
+        } catch (err) {
+            console.error(`✗ FAIL: ${t.desc}`);
+            console.error(`  Error: ${err.message}`);
+            testsFailed++;
+        }
+        for (const af of afterEachFns) await callMaybeAsync(af);
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`Tests passed: ${testsPassed}`);
+    console.log(`Tests failed: ${testsFailed}`);
+    console.log('='.repeat(60));
+    process.exit(testsFailed > 0 ? 1 : 0);
+}
+
+// ---------------------------------------------------------------------------
+// columnar test emulation
+// ---------------------------------------------------------------------------
+async function runColumnarTests() {
+    const path = require('path');
+    const fs = require('fs');
+
+    let beforeEachFns = [];
+    let afterEachFns = [];
+    let tests = [];
+    let currentDescribe = '';
+
+    global.describe = function(desc, fn) {
+        currentDescribe = desc;
+        fn();
+    };
+    global.beforeEach = function(fn) {
+        beforeEachFns.push(fn);
+    };
+    global.afterEach = function(fn) {
+        afterEachFns.push(fn);
+    };
+    global.it = function(desc, fn) {
+        const full = currentDescribe ? `${currentDescribe} ${desc}` : desc;
+        tests.push({desc: full, fn});
+        return { timeout: () => {} };
+    };
+
+    console.log("Columnar File Tests\n" + "=".repeat(60));
+
+    const dir = path.join(__dirname, 'test');
+    const files = fs.readdirSync(dir).filter(f => /^columnar.*\.js$/.test(f));
+    files.forEach(f => require(path.join(dir, f)));
+
+    for (const t of tests) {
+        for (const bf of beforeEachFns) await callMaybeAsync(bf);
+        try {
+            await callMaybeAsync(t.fn);
+            console.log(`✓ PASS: ${t.desc}`);
+            testsPassed++;
+        } catch (err) {
+            console.error(`✗ FAIL: ${t.desc}`);
+            console.error(`  Error: ${err.message}`);
+            testsFailed++;
+        }
+        for (const af of afterEachFns) await callMaybeAsync(af);
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`Tests passed: ${testsPassed}`);
+    console.log(`Tests failed: ${testsFailed}`);
+    console.log('='.repeat(60));
+    process.exit(testsFailed > 0 ? 1 : 0);
+}
+
+console.log("Logistic Regression Unit Tests\n" + "=".repeat(60));
+
+// Test 1: Model instantiation
+test("Should create a LogisticRegression model instance", () => {
+    const model = new LogisticRegression({
+        learningRate: 0.1,
+        iterations: 100
+    });
+    assert(model instanceof LogisticRegression);
+    assert.strictEqual(model.learningRate, 0.1);
+    assert.strictEqual(model.iterations, 100);
+});
+
+// Test 2: Model fit
+test("Should fit a model with training data", () => {
+    const model = new LogisticRegression({
+        learningRate: 0.1,
+        iterations: 100
+    });
+    const X = [[0, 0], [0, 1], [1, 0], [1, 1]];
+    const y = [0, 1, 1, 1];
+    
+    const result = model.fit(X, y);
+    assert(result instanceof LogisticRegression);
+    assert(model.weights !== null);
+    assert.strictEqual(model.weights.length, 3); // 2 features + 1 intercept
+});
+
+// Test 3: Model predict
+test("Should predict class labels", () => {
+    const model = new LogisticRegression({
+        learningRate: 0.1,
+        iterations: 100
+    });
+    const X = [[0, 0], [0, 1], [1, 0], [1, 1]];
+    const y = [0, 1, 1, 1];
+    
+    model.fit(X, y);
+    const predictions = model.predict([[0, 0], [1, 1], [0, 1]]);
+    
+    assert(Array.isArray(predictions));
+    assert.strictEqual(predictions.length, 3);
+    predictions.forEach(pred => {
+        assert([0, 1].includes(pred));
+    });
+});
+
+// Test 4: Model predictProba
+test("Should predict probabilities", () => {
+    const model = new LogisticRegression({
+        learningRate: 0.1,
+        iterations: 100
+    });
+    const X = [[0, 0], [0, 1], [1, 0], [1, 1]];
+    const y = [0, 1, 1, 1];
+    
+    model.fit(X, y);
+    const probs = model.predictProba([[0, 0], [1, 1], [0.5, 0.5]]);
+    
+    assert(Array.isArray(probs));
+    assert.strictEqual(probs.length, 3);
+    probs.forEach(prob => {
+        assert(typeof prob === 'number');
+        assert(prob >= 0 && prob <= 1);
+    });
+});
+
+// Test 5: Model decision function
+test("Should compute decision function (logits)", () => {
+    const model = new LogisticRegression({
+        learningRate: 0.1,
+        iterations: 100
+    });
+    const X = [[0, 0], [0, 1], [1, 0], [1, 1]];
+    const y = [0, 1, 1, 1];
+    
+    model.fit(X, y);
+    const decisions = model.decisionFunction([[0, 0], [1, 1]]);
+    
+    assert(Array.isArray(decisions));
+    assert.strictEqual(decisions.length, 2);
+    decisions.forEach(d => {
+        assert(typeof d === 'number');
+    });
+});
+
+// Test 6: Fit without data
+test("Should throw error when fitting without data", () => {
+    const model = new LogisticRegression();
+    try {
+        model.fit([], []);
+        throw new Error("Should have thrown an error");
+    } catch (err) {
+        assert(err.message.includes("non-empty"));
+    }
+});
+
+// Test 7: Mismatched dimensions
+test("Should throw error when X and y have different lengths", () => {
+    const model = new LogisticRegression();
+    try {
+        model.fit([[0, 0], [1, 1]], [0, 1, 1]);
+        throw new Error("Should have thrown an error");
+    } catch (err) {
+        assert(err.message.includes("same number"));
+    }
+});
+
+// Test 8: Predict before fit
+test("Should throw error when predicting before fitting", () => {
+    const model = new LogisticRegression();
+    try {
+        model.predict([[0, 0]]);
+        throw new Error("Should have thrown an error");
+    } catch (err) {
+        assert(err.message.includes("not fitted"));
+    }
+});
+
+// Test 9: L2 regularization
+test("Should support L2 regularization", () => {
+    const model = new LogisticRegression({
+        learningRate: 0.1,
+        iterations: 100,
+        l2: 0.01
+    });
+    const X = [[0, 0], [0, 1], [1, 0], [1, 1]];
+    const y = [0, 1, 1, 1];
+    
+    model.fit(X, y);
+    const predictions = model.predict([[0.5, 0.5]]);
+    
+    assert(Array.isArray(predictions));
+    assert.strictEqual(predictions.length, 1);
+});
+
+// Test 10: Custom threshold
+test("Should use custom threshold for prediction", () => {
+    const model = new LogisticRegression({
+        learningRate: 0.1,
+        iterations: 100
+    });
+    const X = [[0, 0], [0, 1], [1, 0], [1, 1]];
+    const y = [0, 1, 1, 1];
+    
+    model.fit(X, y);
+    const predictions = model.predict([[0.5, 0.5]], 0.7);
+    
+    assert(Array.isArray(predictions));
+    assert([0, 1].includes(predictions[0]));
+});
+
+// Summary
+console.log("\n" + "=".repeat(60));
+console.log(`Tests passed: ${testsPassed}`);
+console.log(`Tests failed: ${testsFailed}`);
+console.log("=".repeat(60));
+
+if (testsFailed > 0) {
+    console.log("\nSome tests failed!");
+    process.exit(1);
+} else {
+    console.log("\nAll tests passed! ✓");
+    process.exit(0);
+}

package/test_select.js

@@ -0,0 +1,37 @@
+const { SimpleColumnarStore } = require('./columnar/columnar.js');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+(async () => {
+  const tmp = path.join(os.tmpdir(), 'test-select-issue.columnar');
+  if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+
+  const records = [
+    { id: 1, name: 'Alice', age: 25 },
+    { id: 2, name: 'Bob', age: 30 },
+    { id: 3, name: 'Charlie', age: 35 },
+    { id: 4, name: 'Diana', age: 28 },
+    { id: 5, name: 'Eve', age: 32 },
+    { id: 6, name: 'Frank', age: 29 },
+  ];
+
+  await SimpleColumnarStore.writeRecords(records, tmp);
+
+  // Test the exact SQL from Node-RED
+  const sql = 'SELECT "a1" as test,:msg.payload as name,COUNT(*) AS cnt1 FROM ? a where name= :msg.payload';
+  console.log('Testing SQL:', sql);
+
+  const result = await SimpleColumnarStore.sqlQuery(
+    tmp,
+    sql,
+    null,
+    { msg: { payload: 'Alice' }, flow: {}, global: {} }
+  );
+
+  console.log('Result:', JSON.stringify(result, null, 2));
+  console.log('Number of columns in first record:', Object.keys(result[0]).length);
+  console.log('Column names:', Object.keys(result[0]));
+
+  if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+})();

package/testing/test.js

@@ -74,7 +74,7 @@ function equalObjects(obj1,obj2,errorFactor,callEquals=()=>true,callNotEquals=()
 	if( keys1.length !== keys2.length ) return callNotEquals("different number of properties")
 	for(const key1 of keys1){
 		try{ 
-			if( !equalObjects(obj1[key1],obj2[key1],errorFactor) ) return callNotEquals()
+			if( !equalObjects(obj1[key1],obj2[key1],errorFactor,undefined,err=>{throw Error(err)}) ) return callNotEquals()
 		} catch(ex){
 			return callNotEquals(ex.message)
 		}
@@ -123,17 +123,18 @@ module.exports = function(RED) {
 		node.on("input",function(msg) {
 			if(msg._test) {
 				try{
+					const testData=node.getData(msg,node)
 					if(msg._test.id!==node.id) return setError(msg,node,"Sent by another test "+msg._test.id);
-
 					if(node.isJSONata) 
-						return 	RED.util.evaluateJSONataExpression(node.resultExpression,msg,(err,data)=>{
-							if(err) testedFailed(node,msg,err)
-							else return data?testedOK(node,msg):testedFailed(node,msg,"no data")
+						return 	RED.util.evaluateJSONataExpression(node.resultExpression,testData,(err,data)=>{
+							if(err) return testedFailed(node,msg,err)
+							if(data==null) testedFailed(node,msg,"no data, expecting boolean")
+							return data==true ? testedOK(node,msg) : testedFailed(node,msg,"jsonata not true")
 						})
 					
-					node.equalObjects(node.getData(msg,node),msg._test.result,node.errorFactor,
+					node.equalObjects(testData,msg._test.result,node.errorFactor,
 						()=>testedOK(node,msg),
-						(err)=>testedFailed(node,msg,err)
+						err=>testedFailed(node,msg,"equal object test failure "+err)
 					);
 
 				} catch(ex){

package/transform/transform.html

@@ -27,6 +27,10 @@
 			sourceProperty:{value:"msg.payload"},
 			targetProperty:{value:"msg.payload"},
 			topicProperty:{value:"msg.topic"},
+			JSONataSource:{value:null,validate:v=>v==null||RED.validators.typedInput("JSONataSourceType")},
+			JSONataSourceType:{value:"jsonata"},
+			JSONataTarget:{value:null,validate:v=>v==null||RED.validators.typedInput("JSONataTargetType")},
+			JSONataTargetType:{value:"jsonata"},
 			index: {value:0},
 			maxMessages: {value:1000},
 			maxDate: {value:null},
@@ -104,6 +108,7 @@
 				$(".form-row-http-in-skip").hide();
 				$(".form-row-http-in-schema").hide();
 				$(".form-row-http-in-compressionType").hide();
+				$(".form-row-http-in-JSONataSource").hide();
 				if(!['CSV','CSVWithHeader'].includes(actionSource)) {
 					$(".form-row-http-in-csv").hide();
 				}
@@ -151,6 +156,7 @@
 					options["Array"]="Array";
 					break;
 				case 'JSON':
+					$(".form-row-http-in-JSONataSource").show();
 					options["Array"]="Array";
 					options["AVRO"]="AVRO";
 					options["Compressed"]="Compressed";
@@ -277,7 +283,7 @@
 				$(".form-row-http-in-radix").hide();
 				$(".form-row-http-in-schema").hide();
 				$(".form-row-http-in-string").hide();
-
+				$(".form-row-http-in-JSONataTarget").hide();
 				switch (actionTarget) {
 				case 'AVRO':
 				case 'Confluence':
@@ -317,8 +323,14 @@
  					$(".form-row-http-in-max"+actionSource).show();
  					$(".form-row-http-in-min"+actionSource).show();
 					break;
+				case 'JSON':
+ 					$(".form-row-http-in-max"+actionSource).show();
+				$(".form-row-http-in-JSONataTarget").show();
+					break;
 				}
 			}).change();
+			setInput.apply(this,["JSONataSource",["jsonata"]]);
+			setInput.apply(this,["JSONataTarget",["jsonata"]]);
 			setInput.apply(this,["deleteSource",["bool"]]);
 			setInput.apply(this,["schema"]);
 			setInput.apply(this,["string",["str","msg","flow","global","env","node"]]);
@@ -357,11 +369,21 @@
 		<label for="node-input-actionSource"><i class="fa fa-list-ul"></i> Source Type </label>
 		<input type="text" id="node-input-actionSource">
 	</div>
+	<div class="form-row form-row-http-in-JSONataSource hide">
+		<label for="node-input-JSONataSource"><i class="fa fa-bookmark"></i> <span data-i18n="common.label.string"> JSONata Source</span></label>
+		<input type="text" id="node-input-JSONataSource" style="width:70%">
+		<input type="hidden" id="node-input-JSONataSourceType">
+	</div>
 	<div class="form-row">
 		<label for="node-input-actionTarget"><i class="fa fa-list-ul"></i> Target Type </label>
 		<select id="node-input-actionTarget" placeholder="actionTarget">
 		</select>
 	</div>
+	<div class="form-row form-row-http-in-JSONataTarget hide">
+		<label for="node-input-JSONataTarget"><i class="fa fa-bookmark"></i> <span data-i18n="common.label.string"> JSONata Target</span></label>
+		<input type="text" id="node-input-JSONataTarget" style="width:70%">
+		<input type="hidden" id="node-input-JSONataTargetType">
+	</div>
 	<div class="form-row form-row-http-in-delimiter hide">
 		<label for="node-input-delimiter"><i class="icon-bookmark"></i> Delimiter</label>
 		<input type="text" id="node-input-delimiter" placeholder="delimiter" size="1" minlength="1">
@@ -426,7 +448,6 @@
 		<input type="text" id="node-input-string" style="width:70%">
 		<input type="hidden" id="node-input-stringType">
 	</div>
-
 </script>
 
 <script type="text/x-red" data-help-name="transform">