nodalis-compiler 1.0.0

package/src/compilers/support/nodejs/opcua.js

@@ -0,0 +1,194 @@
+import { IOClient } from './IOClient.js';
+import {
+  OPCUAClient,
+  AttributeIds,
+  DataType,
+  StatusCodes,
+  Variant,
+  OPCUAServer
+} from 'node-opcua';
+
+export class OPCClient extends IOClient {
+  constructor(endpointUrl) {
+    super('OPCUA');
+    this.endpointUrl = endpointUrl;
+    this.client = OPCUAClient.create({ endpoint_must_exist: false });
+    this.session = null;
+  }
+
+  async connect() {
+    try {
+        if(this.moduleID.length > 0){
+            this.endpointUrl = this.moduleID;
+        }
+      console.log(`Connecting to OPC UA server at ${this.endpointUrl}`);
+      await this.client.connect(this.endpointUrl);
+      this.session = await this.client.createSession();
+      this.connected = true;
+      console.log("OPC UA connected.");
+    } catch (err) {
+      console.error("OPC UA connection error:", err);
+      this.connected = false;
+    }
+  }
+
+  getNodeId(remote) {
+    // Expects node format: "SW2" -> "ns=1;s=SW2"
+    return `ns=1;s=${remote}`;
+  }
+
+  async readValue(remote, dataType, callback) {
+    if (!this.connected) return callback(null);
+    try {
+      const nodeId = this.getNodeId(remote);
+      const result = await this.session.read({
+        nodeId,
+        attributeId: AttributeIds.Value
+      });
+      callback(result.value.value);
+    } catch (err) {
+      console.error(`Read error [${remote}]`, err);
+      callback(null);
+    }
+  }
+
+  async writeValue(remote, value, dataType) {
+    if (!this.connected) return;
+    try {
+      const nodeId = this.getNodeId(remote);
+      const variant = new Variant({ dataType, value });
+      const statusCode = await this.session.write({
+        nodeId,
+        attributeId: AttributeIds.Value,
+        value: { value: variant }
+      });
+      if (statusCode !== StatusCodes.Good) {
+        console.warn(`Write to ${remote} failed: ${statusCode.toString()}`);
+      }
+    } catch (err) {
+      console.error(`Write error [${remote}]`, err);
+    }
+  }
+
+  readBit(remote, callback) {
+    this.readValue(remote, DataType.Boolean, callback);
+  }
+
+  writeBit(remote, value) {
+    this.writeValue(remote, !!value, DataType.Boolean);
+  }
+
+  readByte(remote, callback) {
+    this.readValue(remote, DataType.Byte, callback);
+  }
+
+  writeByte(remote, value) {
+    this.writeValue(remote, value, DataType.Byte);
+  }
+
+  readWord(remote, callback) {
+    this.readValue(remote, DataType.UInt16, callback);
+  }
+
+  writeWord(remote, value) {
+    this.writeValue(remote, value, DataType.UInt16);
+  }
+
+  readDWord(remote, callback) {
+    this.readValue(remote, DataType.UInt32, callback);
+  }
+
+  writeDWord(remote, value) {
+    this.writeValue(remote, value, DataType.UInt32);
+  }
+}
+
+
+export class OPCServer {
+  constructor() {
+    this.server = new OPCUAServer({
+      port: 4840,
+      resourcePath: "/UA/Nodalis",
+      buildInfo: {
+        productName: "NodalisServer",
+        buildNumber: "1",
+        buildDate: new Date()
+      }
+    });
+
+    this.addressMap = new Map(); // maps nodeId -> address string
+    this.readCallback = null;
+    this.writeCallback = null;
+  }
+
+  setReadWriteHandlers(readHandler, writeHandler) {
+    this.readCallback = readHandler;
+    this.writeCallback = writeHandler;
+  }
+
+  async initialize() {
+    await this.server.initialize();
+    const addressSpace = this.server.engine.addressSpace;
+    this.namespace = addressSpace.getOwnNamespace();
+  }
+
+  async start() {
+    await this.initialize();
+    await this.server.start();
+    console.log("OPCUA Server is now listening at", this.server.endpoints[0].endpointDescriptions()[0].endpointUrl);
+  }
+
+  async stop() {
+    await this.server.shutdown(1000);
+    console.log("OPCUA Server has shut down.");
+  }
+
+  mapVariable(varname, addr) {
+    const nodeId = `ns=1;s=${varname}`;
+    this.addressMap.set(nodeId, addr);
+
+    this.namespace.addVariable({
+      organizedBy: this.server.engine.addressSpace.rootFolder.objects,
+      nodeId: nodeId,
+      browseName: varname,
+      dataType: this._guessDataType(addr),
+      value: {
+        get: () => this._read(addr),
+        set: (variant) => this._write(addr, variant)
+      }
+    });
+  }
+
+  _read(addr) {
+    if (!this.readCallback) return new Variant({ dataType: DataType.Boolean, value: false });
+    const val = this.readCallback(addr);
+    return new Variant(this._valueToVariant(val));
+  }
+
+  _write(addr, variant) {
+    if (!this.writeCallback) return StatusCodes.BadNotWritable;
+    this.writeCallback(addr, variant.value);
+    return StatusCodes.Good;
+  }
+
+  _guessDataType(addr) {
+    if (addr.includes(".")) return DataType.Boolean;
+    switch (addr[2]) {
+      case 'X': return DataType.Byte;
+      case 'W': return DataType.UInt16;
+      case 'D': return DataType.UInt32;
+      default: return DataType.Boolean;
+    }
+  }
+
+  _valueToVariant(value) {
+    const type = typeof value;
+    if (type === "boolean") return { dataType: DataType.Boolean, value };
+    if (type === "number") {
+      if (value <= 255) return { dataType: DataType.Byte, value };
+      if (value <= 65535) return { dataType: DataType.UInt16, value };
+      return { dataType: DataType.UInt32, value };
+    }
+    return { dataType: DataType.Null, value: null };
+  }
+}

package/src/nodalis.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/* eslint-disable curly */
+/* eslint-disable eqeqeq */
+// Copyright [2025] Nathan Skipper
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+// Updated compiler imports
+import { CPPCompiler } from './compilers/CPPCompiler.js';
+import { JSCompiler } from './compilers/JSCompiler.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const availableCompilers = [
+  new CPPCompiler(),
+  new JSCompiler(),
+];
+
+function validateFileExtension(language, sourcePath) {
+  const ext = path.extname(sourcePath).toLowerCase();
+  if (language === 'st') {
+    if (ext !== '.st' && ext !== '.iec') {
+      throw new Error(`Invalid file extension for language 'st'. Expected '.st' or '.iec', got '${ext}'`);
+    }
+  } else if (language === 'ld') {
+    if (ext !== '.iec') {
+      throw new Error(`Invalid file extension for language 'ld'. Expected '.iec', got '${ext}'`);
+    }
+  } else {
+    throw new Error(`Unknown language: ${language}`);
+  }
+}
+
+export class Nodalis {
+  constructor() {
+    this.compilers = availableCompilers;
+  }
+
+  listCompilers() {
+    return this.compilers.map(c => ({
+      name: c.constructor.name,
+      supportedTargets: c.supportedTargetDevices,
+      supportedOutputTypes: c.supportedOutputTypes,
+      supportedLanguages: c.supportedLanguages,
+      supportedProtocols: c.supportedProtocols,
+      compilerVersion: c.compilerVersion,
+    }));
+  }
+
+  getCompiler(target, outputType, language) {
+    return this.compilers.find(c =>
+      c.supportedTargetDevices.includes(target) &&
+      c.supportedOutputTypes.includes(outputType) &&
+      c.supportedLanguages.includes(language.toUpperCase())
+    );
+  }
+
+  async compile({ target, outputType, outputPath, resourceName, sourcePath, language }) {
+    validateFileExtension(language, sourcePath);
+
+    const compiler = this.getCompiler(target, outputType, language);
+    if (!compiler) {
+      throw new Error(`No compiler found for target "${target}", outputType "${outputType}", and language "${language}"`);
+    }
+
+    compiler.options = {
+      sourcePath,
+      outputPath,
+      resourceName,
+      target,
+      outputType,
+      language,
+    };
+
+    await compiler.compile();
+  }
+}
+
+// === CLI Entry Point ===
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`
+Usage:
+  node nodalis.js --action <action> [options]
+
+Actions:
+  --action list-compilers
+      Lists all available compilers and their supported targets, languages, protocols, and versions.
+
+  --action compile
+      Required options:
+        --target        Target platform (e.g. nodejs, generic-cpp)
+        --outputType    Output type (e.g. code, executable)
+        --outputPath    Directory to write the result
+        --resourceName  Resource name (used for .iec projects)
+        --sourcePath    Path to source file (.st or .iec)
+        --language      st (Structured Text) or ld (Ladder Diagram)
+
+Examples:
+  node nodalis.js --action list-compilers
+
+  node nodalis.js --action compile \\
+    --target nodejs \\
+    --outputType code \\
+    --outputPath ./out \\
+    --resourceName MyPLC \\
+    --sourcePath ./examples/pump.iec \\
+    --language st
+  `);
+  process.exit(0);
+}
+
+  const args = process.argv.slice(2);
+  const argMap = {};
+
+  for (let i = 0; i < args.length; i += 2) {
+    const key = args[i].replace(/^--/, '');
+    const value = args[i + 1];
+    argMap[key] = value;
+  }
+
+  const app = new Nodalis();
+
+  switch (argMap.action) {
+    case 'list-compilers': {
+      const list = app.listCompilers();
+      console.log(JSON.stringify(list, null, 2));
+      break;
+    }
+
+    case 'compile': {
+      app.compile({
+        target: argMap.target,
+        outputType: argMap.outputType,
+        outputPath: argMap.outputPath,
+        resourceName: argMap.resourceName,
+        sourcePath: argMap.sourcePath,
+        language: argMap.language,
+      }).then(() => {
+        console.log('Compilation completed.');
+      }).catch(err => {
+        console.error(`Compilation failed: ${err.message}`);
+      });
+      break;
+    }
+
+    case 'deploy': {
+      console.log(`Deploy action is not yet implemented.`);
+      break;
+    }
+
+    default: {
+      console.error(`Unknown or missing action: ${argMap.action}`);
+      console.error(`Valid actions: list-compilers, compile, deploy`);
+      break;
+    }
+  }
+}