@cyprnet/node-red-contrib-uibuilder-formgen 0.4.13 → 0.5.1

package/nodes/uibuilder-formgen-v3.js

@@ -0,0 +1,482 @@
+/**
+ * PortalSmith FormGen - uibuilder-formgen-v3 node (Vue 3 + Bootstrap 5)
+ * 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) {
+    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 (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);
+      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 };
+    }
+
+    const trimmed = logoPath.replace(/^\.?\/*/, "");
+    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");
+
+    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();
+
+    if (isNonEmptyString(instanceRootDir)) {
+      if (!path.isAbsolute(instanceRootDir)) {
+        throw new Error(`instanceRootDir must be an absolute path. Got: ${instanceRootDir}`);
+      }
+      return { userDir, uibRoot: path.dirname(instanceRootDir), instRoot: instanceRootDir, srcDir: path.join(instanceRootDir, "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)) {
+      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 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");
+    }
+
+    const validTypes = [
+      "text",
+      "textarea",
+      "number",
+      "select",
+      "checkbox",
+      "radio",
+      "date",
+      "keyvalue",
+    ];
+
+    schema.sections.forEach((section, idx) => {
+      if (!section.fields || !Array.isArray(section.fields)) {
+        throw new Error(`Section ${idx + 1} missing required 'fields' array`);
+      }
+      section.fields.forEach((field) => {
+        if (!field.id) throw new Error(`Section ${idx + 1} has a field missing required 'id'`);
+        if (!field.type) throw new Error(`Section ${idx + 1}, field ${field.id} missing required 'type'`);
+        if (!validTypes.includes(field.type)) {
+          throw new Error(`Section ${idx + 1}, field ${field.id} has invalid type: ${field.type}`);
+        }
+        if ((field.type === "select" || field.type === "radio") && field.options && !Array.isArray(field.options)) {
+          throw new Error(`Section ${idx + 1}, field ${field.id} options must be an array`);
+        }
+        if (field.type === "keyvalue" && field.keyvalueMode === "pairs") {
+          if (field.pairs && !Array.isArray(field.pairs)) {
+            throw new Error(`Section ${idx + 1}, field ${field.id} pairs must be an array`);
+          }
+        }
+      });
+    });
+  }
+
+  function calculateSchemaSummary(schema) {
+    const formId = schema.formId || "unknown";
+    const title = schema.title || "PortalSmith Form";
+    let sectionCount = 0;
+    let fieldCount = 0;
+    if (schema.sections && Array.isArray(schema.sections)) {
+      sectionCount = schema.sections.length;
+      schema.sections.forEach(section => {
+        if (section.fields && Array.isArray(section.fields)) {
+          fieldCount += section.fields.length;
+        }
+      });
+    }
+    return { formId, title, sectionCount, fieldCount };
+  }
+
+  function UibuilderFormGenV3Node(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 {
+        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;
+
+          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 (!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;
+        }
+
+        // Schema
+        let schema = msg.schema;
+        if (!schema || typeof schema !== "object") schema = msg.payload;
+        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");
+        validateSchema(schema);
+
+        const instanceName = String(msg.uibuilder ?? msg.options?.instance ?? config.instanceName ?? "formgen").trim();
+        if (!/^[a-zA-Z0-9._-]+$/.test(instanceName)) {
+          throw new Error("Invalid instanceName; use letters/numbers/._- only");
+        }
+
+        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();
+        if (!["auto", "light", "dark"].includes(themeMode)) {
+          throw new Error("themeMode must be 'auto', 'light', or 'dark'");
+        }
+        if (!["file", "localstorage"].includes(storageMode)) {
+          throw new Error("storageMode must be 'file' or 'localstorage'");
+        }
+
+        const validFormats = ["json", "csv", "html"];
+        const invalidFormats = exportFormats.filter(f => !validFormats.includes(f));
+        if (invalidFormats.length > 0) {
+          throw new Error(`Invalid exportFormats: ${invalidFormats.join(", ")}`);
+        }
+
+        const { userDir, uibRoot, instRoot, srcDir } = resolveUibuilderPaths({ RED, config, msg, instanceName });
+        await fs.ensureDir(srcDir);
+
+        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,
+        };
+
+        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 });
+
+        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"); }
+        }
+
+        const targetHtml = path.join(srcDir, "index.html");
+        const targetJs = path.join(srcDir, "index.js");
+        const targetSchema = path.join(srcDir, "form.schema.json");
+        const targetRuntime = path.join(instRoot, "portalsmith.runtime.json");
+
+        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}`);
+          }
+        }
+
+        const schemaSummary = calculateSchemaSummary(schema);
+        const templatesDir = path.join(__dirname, "..", "templates");
+        const htmlTemplate = await fs.readFile(path.join(templatesDir, "index.v3.html.mustache"), "utf8");
+        const jsTemplate = await fs.readFile(path.join(templatesDir, "index.v3.js.mustache"), "utf8");
+
+        const baseUrl = config.uibuilderUrl || "/uibuilder";
+        const htmlViewModel = {
+          title: uiTitle,
+          description: schema.description || "",
+          baseUrl: baseUrl,
+          themeMode: themeMode,
+          logoUrl: logoUrl,
+          logoAlt: logoAlt,
+          licensed: licensePublic.licensed
+        };
+
+        const jsViewModel = {
+          timestamp: new Date().toISOString(),
+          instanceName: instanceName,
+          formId: schema.formId || schemaSummary.formId,
+          storageMode: storageMode,
+          exportFormatsJson: JSON.stringify(exportFormats),
+          baseUrl: baseUrl,
+          themeMode: themeMode,
+          submitMode: submitMode,
+          submitUrl: submitUrl,
+          submitHeadersJson: submitHeadersJson,
+          licenseJson: JSON.stringify(licensePublic)
+        };
+
+        const oldTags = Mustache.tags;
+        Mustache.tags = ['[[', ']]'];
+        let renderedHtml = Mustache.render(htmlTemplate, htmlViewModel);
+        let renderedJs = Mustache.render(jsTemplate, jsViewModel);
+        Mustache.tags = oldTags;
+
+        renderedJs = renderedJs.replace('__EXPORT_FORMATS_JSON__', JSON.stringify(exportFormats));
+        renderedJs = renderedJs.replace('__LICENSE_JSON__', jsViewModel.licenseJson);
+
+        await fs.writeFile(targetHtml, renderedHtml, "utf8");
+        await fs.writeFile(targetJs, renderedJs, "utf8");
+        await fs.writeJson(targetSchema, schema, { spaces: 2 });
+
+        const runtimeData = {
+          generatorVersion: "0.5.0",
+          generatorNode: "uibuilder-formgen-v3",
+          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 });
+
+        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,
+          portalRuntime: "vue3"
+        };
+
+        send(msg);
+        done();
+      } catch (err) {
+        node.error(err, msg);
+        done(err);
+      }
+    });
+  }
+
+  RED.nodes.registerType("uibuilder-formgen-v3", UibuilderFormGenV3Node, {
+    credentials: {
+      licenseKey: { type: "password" },
+    },
+  });
+};
+
+

package/nodes/uibuilder-formgen.js

@@ -463,7 +463,7 @@ module.exports = function(RED) {
 
         // Write runtime metadata
         const runtimeData = {
-          generatorVersion: "0.4.12",
+          generatorVersion: "0.5.0",
           timestamp: new Date().toISOString(),
           instanceName: instanceName,
           storageMode: storageMode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyprnet/node-red-contrib-uibuilder-formgen",
-  "version": "0.4.13",
+  "version": "0.5.1",
   "description": "PortalSmith: Generate schema-driven uibuilder form portals from JSON",
   "keywords": [
     "node-red",
@@ -41,6 +41,7 @@
   "node-red": {
     "nodes": {
       "uibuilder-formgen": "nodes/uibuilder-formgen.js",
+      "uibuilder-formgen-v3": "nodes/uibuilder-formgen-v3.js",
       "portalsmith-license": "nodes/portalsmith-license.js"
     }
   }