@xenonbyte/da-vinci-workflow 0.1.14 → 0.1.16

package/lib/pen-persistence.js

@@ -0,0 +1,326 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const DEFAULT_PEN_VERSION = "2.9";
+const DEFAULT_READ_DEPTH = 50;
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function extractFirstJson(text) {
+  const source = String(text || "");
+  const decoder = new JSONDecoder();
+  return decoder.decodeFirst(source);
+}
+
+class JSONDecoder {
+  constructor() {
+    this.decoder = JSON;
+  }
+
+  decodeFirst(text) {
+    for (let index = 0; index < text.length; index += 1) {
+      const ch = text[index];
+      if (ch !== "{" && ch !== "[") {
+        continue;
+      }
+
+      try {
+        const { value } = this.rawDecode(text.slice(index));
+        return value;
+      } catch (error) {
+        continue;
+      }
+    }
+
+    throw new Error("No JSON payload found.");
+  }
+
+  rawDecode(text) {
+    let end = 0;
+    let inString = false;
+    let escape = false;
+    let depth = 0;
+    const opening = text[0];
+    const closing = opening === "{" ? "}" : "]";
+
+    for (let index = 0; index < text.length; index += 1) {
+      const ch = text[index];
+
+      if (inString) {
+        if (escape) {
+          escape = false;
+        } else if (ch === "\\") {
+          escape = true;
+        } else if (ch === "\"") {
+          inString = false;
+        }
+        continue;
+      }
+
+      if (ch === "\"") {
+        inString = true;
+        continue;
+      }
+
+      if (ch === opening) {
+        depth += 1;
+      } else if (ch === closing) {
+        depth -= 1;
+        if (depth === 0) {
+          end = index + 1;
+          break;
+        }
+      }
+    }
+
+    if (end === 0) {
+      throw new Error("Incomplete JSON payload.");
+    }
+
+    return {
+      value: JSON.parse(text.slice(0, end)),
+      end
+    };
+  }
+}
+
+function readJsonPayload(filePath) {
+  const raw = fs.readFileSync(filePath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    return extractFirstJson(raw);
+  }
+}
+
+function hasTruncatedChildren(value) {
+  if (Array.isArray(value)) {
+    return value.some((item) => hasTruncatedChildren(item));
+  }
+
+  if (!isPlainObject(value)) {
+    return value === "...";
+  }
+
+  return Object.values(value).some((item) => hasTruncatedChildren(item));
+}
+
+function normalizeNodesPayload(payload) {
+  const nodes = getNodesArray(payload);
+
+  if (!nodes) {
+    throw new Error("Nodes payload must be an array or an object with a `nodes` array.");
+  }
+
+  if (hasTruncatedChildren(nodes)) {
+    throw new Error("Nodes payload is truncated (`...`). Re-read the live document with a deeper batch_get before persisting.");
+  }
+
+  return nodes;
+}
+
+function getNodesArray(payload) {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+
+  if (payload && Array.isArray(payload.nodes)) {
+    return payload.nodes;
+  }
+
+  return null;
+}
+
+function normalizeVariablesPayload(payload) {
+  if (!payload) {
+    return undefined;
+  }
+
+  if (isPlainObject(payload.variables)) {
+    return payload.variables;
+  }
+
+  if (isPlainObject(payload)) {
+    return payload;
+  }
+
+  throw new Error("Variables payload must be an object or an object with a `variables` key.");
+}
+
+function buildPenDocument({ version = DEFAULT_PEN_VERSION, nodes, variables }) {
+  const document = {
+    version,
+    children: normalizeNodesPayload(nodes)
+  };
+
+  const normalizedVariables = normalizeVariablesPayload(variables);
+  if (normalizedVariables && Object.keys(normalizedVariables).length > 0) {
+    document.variables = normalizedVariables;
+  }
+
+  return document;
+}
+
+function writePenDocumentAtomic(outputPath, document) {
+  const targetPath = path.resolve(outputPath);
+  const targetDir = path.dirname(targetPath);
+  const tempPath = path.join(
+    targetDir,
+    `.${path.basename(targetPath)}.tmp-${process.pid}-${Date.now()}`
+  );
+
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.writeFileSync(tempPath, JSON.stringify(document, null, 2) + "\n", "utf8");
+  fs.renameSync(tempPath, targetPath);
+  return targetPath;
+}
+
+function runPencilInteractive(inputPath, commands, options = {}) {
+  const pencilBin = options.pencilBin || "pencil";
+  const unusedOutput = path.join(
+    os.tmpdir(),
+    `da-vinci-verify-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.pen`
+  );
+  const payload = Array.isArray(commands) ? commands.join("\n") : String(commands || "");
+  const result = spawnSync(
+    pencilBin,
+    ["interactive", "-i", path.resolve(inputPath), "-o", unusedOutput],
+    {
+      input: `${payload}\nexit()\n`,
+      encoding: "utf8",
+      maxBuffer: 8 * 1024 * 1024
+    }
+  );
+
+  fs.rmSync(unusedOutput, { force: true });
+
+  const stdout = result.stdout || "";
+  const stderr = result.stderr || "";
+  if (result.status !== 0) {
+    throw new Error(
+      `Pencil interactive failed for ${inputPath}.\n${stdout}${stderr}`.trim()
+    );
+  }
+
+  return `${stdout}${stderr}`;
+}
+
+function verifyPenFileWithPencil(filePath, options = {}) {
+  const output = runPencilInteractive(filePath, ['batch_get({ readDepth: 1 })'], options);
+  const payload = extractFirstJson(output);
+  const nodes = getNodesArray(payload);
+  const expectedTopLevelIds = options.expectedTopLevelIds || [];
+
+  if (!nodes) {
+    throw new Error("Pencil reopen verification did not return a `nodes` array.");
+  }
+
+  if (expectedTopLevelIds.length > 0) {
+    const actualIds = nodes.map((node) => node.id);
+    if (JSON.stringify(actualIds) !== JSON.stringify(expectedTopLevelIds)) {
+      throw new Error(
+        `Reopened .pen file top-level ids do not match. Expected ${expectedTopLevelIds.join(", ")}, got ${actualIds.join(", ")}.`
+      );
+    }
+  }
+
+  return {
+    topLevelCount: nodes.length,
+    topLevelIds: nodes.map((node) => node.id)
+  };
+}
+
+function writePenFromPayloadFiles(options) {
+  const outputPath = path.resolve(options.outputPath);
+  const nodes = readJsonPayload(options.nodesFile);
+  const variables = options.variablesFile ? readJsonPayload(options.variablesFile) : undefined;
+  const document = buildPenDocument({
+    version: options.version || DEFAULT_PEN_VERSION,
+    nodes,
+    variables
+  });
+
+  writePenDocumentAtomic(outputPath, document);
+
+  const verification = options.verifyWithPencil
+    ? verifyPenFileWithPencil(outputPath, {
+        pencilBin: options.pencilBin,
+        expectedTopLevelIds: document.children.map((node) => node.id)
+      })
+    : null;
+
+  return {
+    outputPath,
+    document,
+    verification
+  };
+}
+
+function readPenVersion(inputPath) {
+  const payload = JSON.parse(fs.readFileSync(inputPath, "utf8"));
+  return payload.version || DEFAULT_PEN_VERSION;
+}
+
+function capturePenSnapshot(inputPath, options = {}) {
+  const readDepth = options.readDepth || DEFAULT_READ_DEPTH;
+  const nodesOutput = runPencilInteractive(
+    inputPath,
+    [
+      `batch_get({ readDepth: ${readDepth}, includePathGeometry: true, resolveInstances: false, resolveVariables: false })`
+    ],
+    options
+  );
+  const variablesOutput = runPencilInteractive(inputPath, ["get_variables()"], options);
+
+  return {
+    nodes: normalizeNodesPayload(extractFirstJson(nodesOutput)),
+    variables: normalizeVariablesPayload(extractFirstJson(variablesOutput))
+  };
+}
+
+function snapshotPenFile(options) {
+  const inputPath = path.resolve(options.inputPath);
+  const outputPath = path.resolve(options.outputPath);
+  const snapshot = capturePenSnapshot(inputPath, options);
+  const document = buildPenDocument({
+    version: options.version || readPenVersion(inputPath),
+    nodes: snapshot.nodes,
+    variables: snapshot.variables
+  });
+
+  writePenDocumentAtomic(outputPath, document);
+
+  const verification = options.verifyWithPencil
+    ? verifyPenFileWithPencil(outputPath, {
+        pencilBin: options.pencilBin,
+        expectedTopLevelIds: document.children.map((node) => node.id)
+      })
+    : null;
+
+  return {
+    inputPath,
+    outputPath,
+    document,
+    verification
+  };
+}
+
+module.exports = {
+  DEFAULT_PEN_VERSION,
+  DEFAULT_READ_DEPTH,
+  extractFirstJson,
+  readJsonPayload,
+  normalizeNodesPayload,
+  normalizeVariablesPayload,
+  buildPenDocument,
+  writePenDocumentAtomic,
+  runPencilInteractive,
+  verifyPenFileWithPencil,
+  writePenFromPayloadFiles,
+  capturePenSnapshot,
+  snapshotPenFile
+};