@cyprnet/node-red-contrib-uibuilder-formgen 0.4.11

package/nodes/uibuilder-formgen.js

@@ -0,0 +1,598 @@
+/**
+ * PortalSmith FormGen - uibuilder-formgen node
+ * SPDX-License-Identifier: MIT
+ *
+ * Copyright (c) 2026 CyprNet Solutions, LLC
+ */
+
+module.exports = function(RED) {
+  const path = require("path");
+  const fs = require("fs-extra");
+  const Mustache = require("mustache");
+  const crypto = require("crypto");
+  const http = require("http");
+  const https = require("https");
+  const licensing = require("../lib/licensing");
+
+  // Register admin endpoints once (used by the editor UI to show license status)
+  let _adminRegistered = false;
+  function registerAdminEndpoints() {
+    if (_adminRegistered) return;
+    _adminRegistered = true;
+    if (!RED.httpAdmin) return;
+
+    const guard =
+      RED.auth && typeof RED.auth.needsPermission === "function"
+        ? RED.auth.needsPermission("uibuilder-formgen.read")
+        : function (_req, _res, next) { next(); };
+
+    RED.httpAdmin.post("/portalsmith/license/validate", guard, function (req, res) {
+      try {
+        const body = req.body || {};
+        const licenseKey = String(body.licenseKey || "").trim();
+        const licenseConfigId = String(body.licenseConfigId || "").trim();
+
+        let resolvedKey = licenseKey;
+        if (!resolvedKey && licenseConfigId) {
+          const cfg = RED.nodes.getNode(licenseConfigId);
+          resolvedKey = String(cfg && cfg.credentials ? cfg.credentials.licenseKey : "").trim();
+        }
+
+        const result = licensing.resolveLicenseString(resolvedKey);
+        const verifier = licensing.getVerifierPublicKey();
+        res.json({
+          ok: true,
+          licensed: result.licensed,
+          tier: result.tier,
+          reason: result.reason,
+          displayName: result.display && result.display.displayName ? result.display.displayName : "",
+          licensedTo: result.display && result.display.licensedTo ? result.display.licensedTo : "",
+          expiresAt: result.display && result.display.expiresAt ? result.display.expiresAt : "",
+          features: result.features || {},
+          policy: result.policy || {},
+          verifier: {
+            source: verifier.source,
+            fingerprint: licensing.publicKeyFingerprint(verifier.pem),
+          }
+        });
+      } catch (e) {
+        res.status(500).json({ ok: false, error: String(e && e.message ? e.message : e) });
+      }
+    });
+  }
+  registerAdminEndpoints();
+
+  function isNonEmptyString(v) {
+    return typeof v === "string" && v.trim().length > 0;
+  }
+
+  function safeBasename(filename) {
+    // Basic hardening: strip path separators
+    return path.basename(String(filename || "").replace(/[/\\]+/g, "_"));
+  }
+
+  async function maybePrepareLogo({ logoPathRaw, logoAltRaw, srcDir }) {
+    const logoPath = String(logoPathRaw ?? "").trim();
+    const logoAlt = String(logoAltRaw ?? "Logo").trim() || "Logo";
+
+    if (!isNonEmptyString(logoPath)) {
+      return { logoUrl: "", logoAlt: logoAlt };
+    }
+
+    // If absolute path, copy it into src/images and reference it as a relative URL
+    if (path.isAbsolute(logoPath)) {
+      const exists = await fs.pathExists(logoPath);
+      if (!exists) {
+        throw new Error(`logoPath does not exist: ${logoPath}`);
+      }
+
+      const imagesDir = path.join(srcDir, "images");
+      await fs.ensureDir(imagesDir);
+
+      const srcBase = safeBasename(logoPath);
+      // Avoid collisions if user generates multiple times with different files of same name
+      const hash = crypto.createHash("sha1").update(logoPath).digest("hex").slice(0, 8);
+      const outName = `${hash}-${srcBase}`;
+      const outPath = path.join(imagesDir, outName);
+
+      await fs.copy(logoPath, outPath, { overwrite: true, errorOnExist: false });
+      return { logoUrl: `./images/${outName}`, logoAlt };
+    }
+
+    // Non-absolute: assume it's a filename under src/images/
+    const trimmed = logoPath.replace(/^\.?\/*/, ""); // remove leading ./ or /
+    const fileOnly = safeBasename(trimmed);
+    return { logoUrl: `./images/${fileOnly}`, logoAlt };
+  }
+
+  async function httpRequestJson({ url, method, headers, body, insecureTls, timeoutMs }) {
+    const urlObj = new URL(url);
+    const isHttps = urlObj.protocol === "https:";
+    const lib = isHttps ? https : http;
+
+    const reqHeaders = Object.assign({}, headers || {});
+    let bodyStr = "";
+    if (body !== undefined) {
+      bodyStr = typeof body === "string" ? body : JSON.stringify(body);
+      if (!reqHeaders["Content-Type"] && !reqHeaders["content-type"]) {
+        reqHeaders["Content-Type"] = "application/json";
+      }
+      reqHeaders["Content-Length"] = Buffer.byteLength(bodyStr);
+    }
+
+    const agent = isHttps
+      ? new https.Agent({ rejectUnauthorized: insecureTls ? false : true })
+      : undefined;
+
+    const options = {
+      method: method || "POST",
+      protocol: urlObj.protocol,
+      hostname: urlObj.hostname,
+      port: urlObj.port || (isHttps ? 443 : 80),
+      path: urlObj.pathname + urlObj.search,
+      headers: reqHeaders,
+      agent,
+      timeout: Number(timeoutMs || 15000),
+    };
+
+    return await new Promise((resolve, reject) => {
+      const req = lib.request(options, (res) => {
+        const chunks = [];
+        res.on("data", (d) => chunks.push(d));
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString("utf8");
+          const ct = String(res.headers["content-type"] || "").toLowerCase();
+          let json = null;
+          if (ct.includes("application/json")) {
+            try { json = JSON.parse(text); } catch (e) { /* ignore */ }
+          }
+          resolve({
+            status: res.statusCode || 0,
+            headers: res.headers,
+            text,
+            json,
+          });
+        });
+      });
+
+      req.on("timeout", () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.on("error", reject);
+
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  }
+
+  function resolveUibuilderPaths({ RED, config, msg, instanceName }) {
+    const userDir = RED.settings.userDir || path.join(process.env.HOME || "", ".node-red");
+
+    // Optional overrides (msg wins over config)
+    const projectName = String(msg.options?.projectName ?? config.projectName ?? "").trim();
+    const uibRootDir = String(msg.options?.uibRootDir ?? msg.options?.uibRoot ?? config.uibRootDir ?? "").trim();
+    const instanceRootDir = String(msg.options?.instanceRootDir ?? config.instanceRootDir ?? "").trim();
+
+    // Precedence:
+    // 1) instanceRootDir (full path to instance root)
+    // 2) uibRootDir (full path to uibuilder root) + instanceName
+    // 3) projectName (derive: userDir/projects/<projectName>/uibuilder) + instanceName
+    // 4) default: userDir/uibuilder + instanceName
+
+    if (isNonEmptyString(instanceRootDir)) {
+      if (!path.isAbsolute(instanceRootDir)) {
+        throw new Error(`instanceRootDir must be an absolute path. Got: ${instanceRootDir}`);
+      }
+      const instRoot = instanceRootDir;
+      return {
+        userDir,
+        uibRoot: path.dirname(instRoot),
+        instRoot,
+        srcDir: path.join(instRoot, "src"),
+      };
+    }
+
+    let uibRoot;
+    if (isNonEmptyString(uibRootDir)) {
+      if (!path.isAbsolute(uibRootDir)) {
+        throw new Error(`uibRootDir must be an absolute path. Got: ${uibRootDir}`);
+      }
+      uibRoot = uibRootDir;
+    } else if (isNonEmptyString(projectName)) {
+      // Common Node-RED projects layout
+      uibRoot = path.join(userDir, "projects", projectName, "uibuilder");
+    } else {
+      uibRoot = path.join(userDir, "uibuilder");
+    }
+
+    const instRoot = path.join(uibRoot, instanceName);
+    return { userDir, uibRoot, instRoot, srcDir: path.join(instRoot, "src") };
+  }
+
+  function UibuilderFormGenNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const licenseConfigNode = config.licenseConfig ? RED.nodes.getNode(config.licenseConfig) : null;
+
+    node.on("input", async function(msg, send, done) {
+      try {
+        // Handle runtime submit proxy (messages coming back from uibuilder)
+        const payload = msg && (msg.payload ?? msg);
+        if (payload && typeof payload === "object" && payload.type === "submit") {
+          const formId = payload.formId || "";
+          const submitPayload = payload.payload ?? payload.data ?? payload;
+
+          // Determine API config (msg.options overrides node config)
+          const apiUrl = String(msg.options?.apiUrl ?? config.apiUrl ?? "").trim();
+          const apiMethod = String(msg.options?.apiMethod ?? config.apiMethod ?? "POST").trim().toUpperCase();
+          const apiHeadersJson = String(msg.options?.apiHeadersJson ?? config.apiHeadersJson ?? "").trim();
+          const apiInsecureTls = (msg.options?.apiInsecureTls ?? config.apiInsecureTls) === true;
+          const apiTimeoutMs = Number(msg.options?.apiTimeoutMs ?? config.apiTimeoutMs ?? 15000);
+
+          let apiHeaders = {};
+          if (isNonEmptyString(apiHeadersJson)) {
+            try { apiHeaders = JSON.parse(apiHeadersJson); } catch (e) { throw new Error("apiHeadersJson must be valid JSON"); }
+          }
+
+          // If no apiUrl configured, just pass-through submit (so flows can handle it)
+          if (!isNonEmptyString(apiUrl)) {
+            msg.payload = {
+              type: "submit:ok",
+              formId,
+              result: { passthrough: true, payload: submitPayload },
+              status: 0,
+            };
+            send(msg);
+            done();
+            return;
+          }
+
+          const apiBody = {
+            formId,
+            payload: submitPayload,
+            meta: payload.meta || {},
+          };
+
+          const resp = await httpRequestJson({
+            url: apiUrl,
+            method: apiMethod,
+            headers: apiHeaders,
+            body: apiBody,
+            insecureTls: apiInsecureTls,
+            timeoutMs: apiTimeoutMs,
+          });
+
+          msg.payload = {
+            type: resp.status >= 200 && resp.status < 300 ? "submit:ok" : "submit:error",
+            formId,
+            status: resp.status,
+            result: resp.json !== null ? resp.json : resp.text,
+            responseHeaders: resp.headers,
+          };
+
+          send(msg);
+          done();
+          return;
+        }
+
+        // Get schema from msg.schema (preferred) or msg.payload (fallback)
+        let schema = msg.schema;
+        if (!schema || typeof schema !== "object") {
+          schema = msg.payload;
+        }
+        
+        // If schema is a string, try to parse it as JSON
+        if (typeof schema === "string") {
+          try {
+            schema = JSON.parse(schema);
+          } catch (e) {
+            throw new Error("msg.schema or msg.payload must be a JSON object or valid JSON string");
+          }
+        }
+        
+        if (!schema || typeof schema !== "object") {
+          throw new Error("Missing required msg.schema or msg.payload object");
+        }
+
+        // Validate schema structure
+        validateSchema(schema);
+
+        // Get instanceName from msg.uibuilder (preferred) or config
+        const instanceName = String(
+          msg.uibuilder ??
+          msg.options?.instance ??
+          config.instanceName ??
+          "formgen"
+        ).trim();
+
+        // Validate instanceName pattern
+        if (!/^[a-zA-Z0-9._-]+$/.test(instanceName)) {
+          throw new Error("Invalid instanceName; use letters/numbers/._- only");
+        }
+
+        // Get options
+        const overwrite = (msg.options?.overwrite ?? config.overwrite) !== false;
+        const storageMode = msg.options?.storageMode ?? config.storageMode ?? "file";
+        const exportFormats = msg.options?.exportFormats ?? 
+          (config.exportFormats ? JSON.parse(config.exportFormats) : ["json", "csv", "html"]);
+        const uiTitle = msg.options?.uiTitle ?? schema.title ?? "PortalSmith Form";
+        const themeMode = String(msg.options?.themeMode ?? config.themeMode ?? "auto").trim().toLowerCase();
+
+      // Validate themeMode
+      if (!["auto", "light", "dark"].includes(themeMode)) {
+        throw new Error("themeMode must be 'auto', 'light', or 'dark'");
+      }
+
+        // Validate storageMode
+        if (!["file", "localstorage"].includes(storageMode)) {
+          throw new Error("storageMode must be 'file' or 'localstorage'");
+        }
+
+        // Validate exportFormats
+        const validFormats = ["json", "csv", "html"];
+        const invalidFormats = exportFormats.filter(f => !validFormats.includes(f));
+        if (invalidFormats.length > 0) {
+          throw new Error(`Invalid exportFormats: ${invalidFormats.join(", ")}`);
+        }
+
+        // Resolve output folders (supports Node-RED Projects and explicit path overrides)
+        const { userDir, uibRoot, instRoot, srcDir } = resolveUibuilderPaths({
+          RED,
+          config,
+          msg,
+          instanceName,
+        });
+
+        // Create folders
+        await fs.ensureDir(srcDir);
+
+        // Licensing (offline-first): missing/invalid => FREE (watermarked)
+        const license = licensing.resolveLicense({ node, RED, licenseConfigNode });
+        const licensePublic = {
+          licensed: Boolean(license.licensed),
+          tier: license.tier || "FREE",
+          watermark: Boolean(license.policy && license.policy.watermark),
+          brandingLocked: Boolean(license.policy && license.policy.brandingLocked),
+          displayName: String(license.display && license.display.displayName ? license.display.displayName : ""),
+          reason: String(license.reason || "missing"),
+          brandingAttempted: false,
+        };
+
+        // Logo (optional): absolute path will be copied into src/images automatically
+        const logoRequested = isNonEmptyString(msg.options?.logoPath ?? config.logoPath ?? "");
+        let logoPathRaw = msg.options?.logoPath ?? config.logoPath ?? "";
+        const logoAltRaw = msg.options?.logoAlt ?? config.logoAlt ?? "Logo";
+        if (isNonEmptyString(logoPathRaw) && licensePublic.brandingLocked) {
+          node.warn("PortalSmith FormGen: custom logo is disabled in Free mode (watermarked). Using default branding.");
+          licensePublic.brandingAttempted = Boolean(logoRequested);
+          logoPathRaw = "";
+        }
+        const { logoUrl, logoAlt } = await maybePrepareLogo({ logoPathRaw, logoAltRaw, srcDir });
+
+        // Submit configuration (optional)
+        const submitMode = String(msg.options?.submitMode ?? config.submitMode ?? "uibuilder").trim().toLowerCase();
+        const submitUrl = String(msg.options?.submitUrl ?? config.submitUrl ?? "").trim();
+        const submitHeadersJson = String(msg.options?.submitHeadersJson ?? config.submitHeadersJson ?? "").trim();
+
+        if (!["uibuilder", "http"].includes(submitMode)) {
+          throw new Error("submitMode must be 'uibuilder' or 'http'");
+        }
+        if (submitMode === "http" && !isNonEmptyString(submitUrl)) {
+          throw new Error("submitUrl is required when submitMode is 'http'");
+        }
+        if (isNonEmptyString(submitHeadersJson)) {
+          try { JSON.parse(submitHeadersJson); } catch (e) { throw new Error("submitHeadersJson must be valid JSON"); }
+        }
+
+        // Define target files (write to src/ folder)
+        const targetHtml = path.join(srcDir, "index.html");
+        const targetJs = path.join(srcDir, "index.js");
+        // Schema goes in src/ so frontend can load it via fetch('./form.schema.json')
+        const targetSchema = path.join(srcDir, "form.schema.json");
+        // Runtime metadata can stay in root for reference
+        const targetRuntime = path.join(instRoot, "portalsmith.runtime.json");
+
+        // Check overwrite flag
+        if (!overwrite) {
+          const existingFiles = [targetHtml, targetJs, targetSchema, targetRuntime];
+          for (const f of existingFiles) {
+            if (await fs.pathExists(f)) {
+              throw new Error(`File exists and overwrite=false: ${f}`);
+            }
+          }
+        }
+
+        // Calculate schema summary
+        const schemaSummary = calculateSchemaSummary(schema);
+
+        // Load mustache templates
+        const templatesDir = path.join(__dirname, "..", "templates");
+        const htmlTemplate = await fs.readFile(
+          path.join(templatesDir, "index.html.mustache"),
+          "utf8"
+        );
+        const jsTemplate = await fs.readFile(
+          path.join(templatesDir, "index.js.mustache"),
+          "utf8"
+        );
+
+        // Prepare view model for HTML template
+        const baseUrl = config.uibuilderUrl || "/uibuilder";
+        const htmlViewModel = {
+          title: uiTitle,
+          description: schema.description || "",
+          baseUrl: baseUrl,
+          themeMode: themeMode,
+          logoUrl: logoUrl,
+          logoAlt: logoAlt,
+          licensed: licensePublic.licensed
+        };
+
+        // Prepare view model for JS template
+        const jsViewModel = {
+          timestamp: new Date().toISOString(),
+          instanceName: instanceName,
+          formId: schema.formId || schemaSummary.formId,
+          storageMode: storageMode,
+          exportFormatsJson: JSON.stringify(exportFormats), // Pass as JSON string
+          baseUrl: baseUrl,
+          themeMode: themeMode,
+          submitMode: submitMode,
+          submitUrl: submitUrl,
+          submitHeadersJson: submitHeadersJson,
+          licenseJson: JSON.stringify(licensePublic)
+        };
+
+        // Render templates
+        // Use custom delimiters for Mustache to avoid conflicts with Vue bindings
+        // Mustache will use [[ ]] instead of {{ }}
+        const oldTags = Mustache.tags;
+        Mustache.tags = ['[[', ']]'];
+        let renderedHtml = Mustache.render(htmlTemplate, htmlViewModel);
+        let renderedJs = Mustache.render(jsTemplate, jsViewModel);
+        Mustache.tags = oldTags; // Restore default
+        
+        // Post-process: replace JSON placeholder with actual JSON (unescaped)
+        renderedJs = renderedJs.replace('__EXPORT_FORMATS_JSON__', JSON.stringify(exportFormats));
+        renderedJs = renderedJs.replace('__LICENSE_JSON__', jsViewModel.licenseJson);
+
+        // Write files
+        await fs.writeFile(targetHtml, renderedHtml, "utf8");
+        await fs.writeFile(targetJs, renderedJs, "utf8");
+        await fs.writeJson(targetSchema, schema, { spaces: 2 });
+
+        // Write runtime metadata
+        const runtimeData = {
+          generatorVersion: "0.4.9",
+          timestamp: new Date().toISOString(),
+          instanceName: instanceName,
+          storageMode: storageMode,
+          exportFormats: exportFormats,
+          themeMode: themeMode,
+          logoUrl: logoUrl || "",
+          logoAlt: logoAlt || "",
+          submitMode: submitMode,
+          submitUrl: submitUrl,
+          license: licensePublic,
+          schemaSummary: schemaSummary
+        };
+        await fs.writeJson(targetRuntime, runtimeData, { spaces: 2 });
+
+        // Set output payload
+        msg.payload = {
+          status: "generated",
+          instance: instanceName,
+          uibRoot: uibRoot,
+          path: instRoot,
+          srcPath: srcDir,
+          userDir: userDir,
+          url: `${baseUrl}/${instanceName}/`,
+          files: ["src/index.html", "src/index.js", "src/form.schema.json", "portalsmith.runtime.json"],
+          schemaSummary: schemaSummary
+        };
+
+        send(msg);
+        done();
+      } catch (err) {
+        node.error(err, msg);
+        done(err);
+      }
+    });
+  }
+
+  function validateSchema(schema) {
+    if (!schema.schemaVersion) {
+      throw new Error("Schema missing required 'schemaVersion' field");
+    }
+
+    if (!schema.sections || !Array.isArray(schema.sections)) {
+      throw new Error("Schema missing required 'sections' array");
+    }
+
+    if (schema.sections.length === 0) {
+      throw new Error("Schema must have at least one section");
+    }
+
+    // Validate each section
+    schema.sections.forEach((section, idx) => {
+      if (!section.fields || !Array.isArray(section.fields)) {
+        throw new Error(`Section ${idx} missing required 'fields' array`);
+      }
+
+      if (section.fields.length === 0) {
+        throw new Error(`Section ${idx} must have at least one field`);
+      }
+
+      // Validate each field
+      section.fields.forEach((field, fieldIdx) => {
+        if (!field.id && !field.key) {
+          throw new Error(`Section ${idx}, field ${fieldIdx} missing required 'id' or 'key'`);
+        }
+
+        // Normalize: use 'id' if 'key' is present
+        if (field.key && !field.id) {
+          field.id = field.key;
+        }
+
+        if (!field.type) {
+          throw new Error(`Section ${idx}, field ${field.id} missing required 'type'`);
+        }
+
+        const validTypes = ["text", "textarea", "number", "select", "checkbox", "radio", "date", "keyvalue"];
+        if (!validTypes.includes(field.type)) {
+          throw new Error(`Section ${idx}, field ${field.id} has invalid type: ${field.type}`);
+        }
+
+        // Validate select/radio options
+        if ((field.type === "select" || field.type === "radio") && !field.options) {
+          throw new Error(`Section ${idx}, field ${field.id} (${field.type}) missing required 'options'`);
+        }
+
+        // Validate keyvalue fields
+        if (field.type === "keyvalue") {
+          const mode = field.keyvalueMode || "pairs";
+          if (mode === "pairs") {
+            if (!field.pairs || !Array.isArray(field.pairs) || field.pairs.length === 0) {
+              throw new Error(`Section ${idx}, field ${field.id} (keyvalue pairs mode) requires at least one key-value pair`);
+            }
+          } else if (mode === "delimiter") {
+            if (!field.keyvalueDelimiter || String(field.keyvalueDelimiter).trim() === "") {
+              throw new Error(`Section ${idx}, field ${field.id} (keyvalue delimiter mode) requires a delimiter`);
+            }
+          } else {
+            throw new Error(`Section ${idx}, field ${field.id} (keyvalue) has invalid mode: ${mode}. Must be 'pairs' or 'delimiter'`);
+          }
+        }
+      });
+    });
+  }
+
+  function calculateSchemaSummary(schema) {
+    const formId = schema.formId || "unknown";
+    const title = schema.title || "Untitled Form";
+    const sectionCount = schema.sections ? schema.sections.length : 0;
+    
+    let fieldCount = 0;
+    if (schema.sections) {
+      schema.sections.forEach(section => {
+        if (section.fields) {
+          fieldCount += section.fields.length;
+        }
+      });
+    }
+
+    return {
+      formId: formId,
+      title: title,
+      sectionCount: sectionCount,
+      fieldCount: fieldCount
+    };
+  }
+
+  RED.nodes.registerType("uibuilder-formgen", UibuilderFormGenNode, {
+    credentials: {
+      licenseKey: { type: "password" },
+    },
+  });
+};
+

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@cyprnet/node-red-contrib-uibuilder-formgen",
+  "version": "0.4.11",
+  "description": "PortalSmith: Generate schema-driven uibuilder form portals from JSON",
+  "keywords": [
+    "node-red",
+    "node-red-contrib",
+    "uibuilder",
+    "form",
+    "form-generator",
+    "schema",
+    "json-schema",
+    "portal",
+    "workflow-automation",
+    "bootstrap",
+    "vue"
+  ],
+  "license": "MIT",
+  "author": "CyprNet Solutions, LLC (CyprNet Solutions)",
+  "homepage": "https://www.cyprnetsolutions.com",
+  "main": "index.js",
+  "files": [
+    "nodes",
+    "templates",
+    "examples",
+    "docs",
+    "scripts",
+    "lib",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "lint": "echo \"(optional) add eslint later\"",
+    "test": "echo \"no tests yet\""
+  },
+  "dependencies": {
+    "fs-extra": "^11.2.0",
+    "mustache": "^4.2.0"
+  },
+  "node-red": {
+    "nodes": {
+      "uibuilder-formgen": "nodes/uibuilder-formgen.js",
+      "portalsmith-license": "nodes/portalsmith-license.js"
+    }
+  }
+}