node-pptx-templater 1.0.0

package/src/managers/charts/ChartCacheGenerator.js

@@ -0,0 +1,156 @@
+import { createLogger } from '../../utils/logger.js';
+import { ChartWorkbookUpdater } from './ChartWorkbookUpdater.js';
+
+const logger = createLogger('ChartCacheGenerator');
+
+export class ChartCacheGenerator {
+  /**
+   * Generates a string cache XML string (used for categories or series names).
+   */
+  static generateStrCache(values) {
+    const ptEntries = values
+      .map((val, i) => `<c:pt idx="${i}"><c:v>${this.#escapeXml(String(val))}</c:v></c:pt>`)
+      .join('');
+    return `<c:strCache><c:ptCount val="${values.length}"/>${ptEntries}</c:strCache>`;
+  }
+
+  /**
+   * Generates a numeric cache XML string.
+   */
+  static generateNumCache(values) {
+    const ptEntries = values
+      .map((val, i) => `<c:pt idx="${i}"><c:v>${Number(val) || 0}</c:v></c:pt>`)
+      .join('');
+    return `<c:numCache><c:formatCode>General</c:formatCode><c:ptCount val="${values.length}"/>${ptEntries}</c:numCache>`;
+  }
+
+  /**
+   * Updates category cache and formulas in a chart XML.
+   *
+   * @param {string} xml - Raw chart XML.
+   * @param {string[]} categories - Array of categories.
+   * @param {string} sheetName - Target worksheet name.
+   */
+  static updateCategories(xml, categories, sheetName = 'Sheet1') {
+    const count = categories.length;
+
+    // Formula for categories: Sheet1!$A$2:$A$N
+    const formula = ChartWorkbookUpdater.getFormulaRange(sheetName, 2, 0, count + 1, 0);
+    const newStrCache = this.generateStrCache(categories);
+
+    // Replace the entire <c:cat> block to ensure correct formula and cache
+    const catPattern = /(<c:cat>)([\s\S]*?)(<\/c:cat>)/g;
+
+    return xml.replace(catPattern, (match, open, content, close) => {
+      // Reconstruct the cat block
+      // Try to determine if it used strRef or numRef originally
+      let refTag = content.includes('<c:numRef>') ? 'numRef' : 'strRef';
+      // But typically categories are strings. Let's use strRef.
+      refTag = 'strRef';
+
+      return `${open}<c:${refTag}><c:f>${formula}</c:f>${newStrCache}</c:${refTag}>${close}`;
+    });
+  }
+
+  /**
+   * Updates series names and values in chart XML.
+   */
+  static updateSeries(xml, series, categoriesLength, sheetName = 'Sheet1') {
+    let updated = xml;
+    const serPattern = /(<c:ser>)([\s\S]*?)(<\/c:ser>)/g;
+    const serMatches = [...updated.matchAll(serPattern)];
+
+    if (serMatches.length === 0) return xml;
+
+    let serIndex = 0;
+    updated = updated.replace(serPattern, (match, open, content, close) => {
+      if (serIndex >= series.length) {
+        // If there are more series templates than data, we could drop them,
+        // but replacing with an empty string might break the XML layout if we're not careful.
+        // Actually, removing extra series is requested: "Allow removing old series".
+        return '';
+      }
+
+      const serData = series[serIndex];
+      const colIndex = serIndex + 1; // Series data starts in column B (1)
+      serIndex++;
+
+      let updatedContent = content;
+
+      // 1. Update Series Name (c:tx)
+      if (serData.name !== undefined) {
+        const nameFormula = ChartWorkbookUpdater.getFormulaSingleCell(sheetName, 1, colIndex);
+        const nameCache = `<c:strCache><c:ptCount val="1"/><c:pt idx="0"><c:v>${this.#escapeXml(serData.name)}</c:v></c:pt></c:strCache>`;
+
+        const txPattern = /(<c:tx>)([\s\S]*?)(<\/c:tx>)/;
+        if (txPattern.test(updatedContent)) {
+          updatedContent = updatedContent.replace(txPattern, (match, p1, p2, p3) => {
+            return `${p1}<c:strRef><c:f>${nameFormula}</c:f>${nameCache}</c:strRef>${p3}`;
+          });
+        } else {
+          // Some charts don't have <c:tx>, we prepend it after <c:order> or <c:idx>
+          const insertAfter = /(<c:order[^>]*>)/;
+          if (insertAfter.test(updatedContent)) {
+            updatedContent = updatedContent.replace(insertAfter, (match, p1) => {
+              return `${p1}<c:tx><c:strRef><c:f>${nameFormula}</c:f>${nameCache}</c:strRef></c:tx>`;
+            });
+          }
+        }
+      }
+
+      // 2. Update Series Values (c:val)
+      if (serData.values !== undefined) {
+        const valuesCount = categoriesLength || serData.values.length;
+        const valFormula = ChartWorkbookUpdater.getFormulaRange(sheetName, 2, colIndex, valuesCount + 1, colIndex);
+        const valCache = this.generateNumCache(serData.values);
+
+        const valPattern = /(<c:val>)([\s\S]*?)(<\/c:val>)/;
+        if (valPattern.test(updatedContent)) {
+          updatedContent = updatedContent.replace(valPattern, (match, p1, p2, p3) => {
+            return `${p1}<c:numRef><c:f>${valFormula}</c:f>${valCache}</c:numRef>${p3}`;
+          });
+        }
+      }
+
+      return `${open}${updatedContent}${close}`;
+    });
+
+    return updated;
+  }
+
+  /**
+   * Clones a series template to support dynamic series addition.
+   */
+  static appendDynamicSeries(xml, targetCount) {
+    const serPattern = /(<c:ser>)([\s\S]*?)(<\/c:ser>)/g;
+    const matches = [...xml.matchAll(serPattern)];
+    if (matches.length === 0 || matches.length >= targetCount) return xml;
+
+    // Use the last series as a template to clone
+    const templateMatch = matches[matches.length - 1];
+    const template = templateMatch[0];
+
+    // Find the end of the last series
+    const lastIndex = templateMatch.index + template.length;
+
+    let newSeriesBlocks = '';
+    for (let i = matches.length; i < targetCount; i++) {
+      let clone = template;
+      // Update c:idx and c:order
+      clone = clone.replace(/(<c:idx val=")\d+("\/>)/g, `$1${i}$2`);
+      clone = clone.replace(/(<c:order val=")\d+("\/>)/g, `$1${i}$2`);
+      newSeriesBlocks += clone;
+    }
+
+    return xml.substring(0, lastIndex) + newSeriesBlocks + xml.substring(lastIndex);
+  }
+
+  static #escapeXml(str) {
+    return str
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&apos;');
+  }
+}

package/src/managers/charts/ChartParser.js

@@ -0,0 +1,43 @@
+import { createLogger } from '../../utils/logger.js';
+
+const logger = createLogger('ChartParser');
+
+export class ChartParser {
+  /**
+   * Finds a chart's relationship ID and type in a slide's XML based on shape name/id.
+   *
+   * @param {string} slideXml
+   * @param {string} chartId
+   * @returns {{ rId: string } | null}
+   */
+  static findChartRIdInSlide(slideXml, chartId) {
+    // Strategy 1: Look for shape with matching name (cNvPr name attribute)
+    const shapeNamePattern = new RegExp(
+      `<p:cNvPr[^>]*name="${chartId}"[^>]*>(?:.*?)<c:chart[^>]*r:id="(rId\\d+)"`,
+      's'
+    );
+    const rIdMatch = shapeNamePattern.exec(slideXml);
+    if (rIdMatch) {
+      return { rId: rIdMatch[1] };
+    }
+
+    // Strategy 2: Find all chart graphicFrames and we will match later in manager
+    return null;
+  }
+
+  /**
+   * Parses the chart XML to extract series and categories for validation.
+   *
+   * @param {string} xml
+   * @returns {Object} Data about the chart configuration
+   */
+  static parseChartData(xml) {
+    // This could be used for validation and extracting current chart cache
+    const ptCountMatch = xml.match(/<c:ptCount val="(\d+)"\/>/);
+    const pointCount = ptCountMatch ? parseInt(ptCountMatch[1], 10) : 0;
+
+    return {
+      pointCount
+    };
+  }
+}

package/src/managers/charts/ChartRelationshipManager.js

@@ -0,0 +1,33 @@
+import { REL_TYPES } from '../RelationshipManager.js';
+
+export class ChartRelationshipManager {
+  /**
+   * Validates and fixes chart relationships.
+   *
+   * @param {RelationshipManager} relationshipManager
+   * @param {ZipManager} zipManager
+   * @param {string} chartZipPath
+   * @returns {Object} validation issues
+   */
+  static validateChartRelationships(relationshipManager, zipManager, chartZipPath) {
+    const issues = { errors: [], warnings: [] };
+    const rels = relationshipManager.getRelationships(chartZipPath);
+
+    let hasWorkbook = false;
+    for (const rel of rels) {
+      if (rel.type === REL_TYPES.PACKAGE) {
+        hasWorkbook = true;
+        const xlsxPath = relationshipManager.resolveTarget(chartZipPath, rel.target);
+        if (!zipManager.hasFile(xlsxPath)) {
+          issues.errors.push(`Embedded workbook missing: ${xlsxPath}`);
+        }
+      }
+    }
+
+    if (!hasWorkbook) {
+      issues.warnings.push(`Chart ${chartZipPath} has no embedded workbook relationship. Live editing in PowerPoint may fail.`);
+    }
+
+    return issues;
+  }
+}

package/src/managers/charts/ChartWorkbookUpdater.js

@@ -0,0 +1,130 @@
+import JSZip from 'jszip';
+import { createLogger } from '../../utils/logger.js';
+
+const logger = createLogger('ChartWorkbookUpdater');
+
+export class ChartWorkbookUpdater {
+  /**
+   * Updates the embedded Excel workbook for a chart.
+   *
+   * @param {Buffer|Uint8Array} workbookData - The raw XLSX buffer.
+   * @param {Object} data - Chart data (categories, series).
+   * @returns {Promise<Buffer>} - The updated XLSX buffer.
+   */
+  static async updateWorkbook(workbookData, data) {
+    if (!workbookData) return null;
+
+    try {
+      const zip = await JSZip.loadAsync(workbookData);
+
+      // Look for sheet1.xml
+      const sheetPath = 'xl/worksheets/sheet1.xml';
+      if (!zip.file(sheetPath)) {
+        logger.warn('sheet1.xml not found in embedded workbook, trying to find first sheet');
+        // fallback to finding the first sheet
+      }
+
+      const newSheetXml = this.#generateSheetXml(data);
+      zip.file(sheetPath, newSheetXml);
+
+      // Clean up any existing Excel tables, as our new sheet data might not align with them
+      const tableFiles = Object.keys(zip.files).filter(f => f.startsWith('xl/tables/'));
+      tableFiles.forEach(f => zip.remove(f));
+
+      const sheetRels = Object.keys(zip.files).filter(f => f.startsWith('xl/worksheets/_rels/'));
+      sheetRels.forEach(f => zip.remove(f));
+
+      const contentTypesFile = zip.file('[Content_Types].xml');
+      if (contentTypesFile) {
+        const contentTypesXml = await contentTypesFile.async('text');
+        const updatedContentTypes = contentTypesXml.replace(/<Override[^>]*PartName="\/xl\/tables\/[^"]*"[^>]*\/>/g, '');
+        zip.file('[Content_Types].xml', updatedContentTypes);
+      }
+
+      return await zip.generateAsync({
+        type: 'nodebuffer',
+        compression: 'DEFLATE',
+        compressionOptions: { level: 6 }
+      });
+    } catch (err) {
+      console.error('Failed to update embedded workbook', err);
+      logger.error('Failed to update embedded workbook', err);
+      return workbookData; // Return original if failed
+    }
+  }
+
+  static #generateSheetXml(data) {
+    const { categories = [], series = [] } = data;
+
+    // Column count = 1 (categories) + series.length
+    const numCols = 1 + series.length;
+    const numRows = 1 + categories.length; // Row 1 = headers
+
+    const lastColLetter = this.getColumnLetter(numCols - 1);
+    const dimensionRef = `A1:${lastColLetter}${numRows}`;
+
+    let sheetData = '<sheetData>';
+
+    // Row 1: Headers (empty cell A1, then series names)
+    sheetData += '<row r="1">';
+    sheetData += `<c r="A1" t="inlineStr"><is><t></t></is></c>`;
+    series.forEach((ser, i) => {
+      const colLetter = this.getColumnLetter(i + 1);
+      sheetData += `<c r="${colLetter}1" t="inlineStr"><is><t>${this.#escapeXml(ser.name || '')}</t></is></c>`;
+    });
+    sheetData += '</row>';
+
+    // Rows 2..N: Data (category name in A, then values)
+    categories.forEach((cat, rowIndex) => {
+      const r = rowIndex + 2; // +1 for 1-based, +1 for header row
+      sheetData += `<row r="${r}">`;
+      sheetData += `<c r="A${r}" t="inlineStr"><is><t>${this.#escapeXml(String(cat))}</t></is></c>`;
+
+      series.forEach((ser, colIndex) => {
+        const colLetter = this.getColumnLetter(colIndex + 1);
+        const val = ser.values && ser.values[rowIndex] !== undefined ? ser.values[rowIndex] : 0;
+        sheetData += `<c r="${colLetter}${r}"><v>${Number(val)}</v></c>`;
+      });
+      sheetData += '</row>';
+    });
+
+    sheetData += '</sheetData>';
+
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="${dimensionRef}"/>
+  <sheetViews><sheetView workbookViewId="0"/></sheetViews>
+  <sheetFormatPr defaultRowHeight="15"/>
+  ${sheetData}
+</worksheet>`;
+  }
+
+  static getColumnLetter(colIndex) {
+    let letter = '';
+    while (colIndex >= 0) {
+      letter = String.fromCharCode(65 + (colIndex % 26)) + letter;
+      colIndex = Math.floor(colIndex / 26) - 1;
+    }
+    return letter;
+  }
+
+  static getFormulaRange(sheetName, startRow, startCol, endRow, endCol) {
+    const startLetter = this.getColumnLetter(startCol);
+    const endLetter = this.getColumnLetter(endCol);
+    return `${sheetName}!$${startLetter}$${startRow}:$${endLetter}$${endRow}`;
+  }
+
+  static getFormulaSingleCell(sheetName, row, col) {
+    const letter = this.getColumnLetter(col);
+    return `${sheetName}!$${letter}$${row}`;
+  }
+
+  static #escapeXml(str) {
+    return str
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&apos;');
+  }
+}

package/src/parsers/XMLParser.js

@@ -0,0 +1,291 @@
+/**
+ * @fileoverview XMLParser - Unified XML parsing and serialization layer.
+ *
+ * Uses fast-xml-parser for high-performance XML → JS object conversion.
+ * Provides consistent, reusable parse/build methods used by all managers.
+ *
+ * Key design decisions:
+ *  - Attributes are stored with '@_' prefix (fast-xml-parser convention)
+ *  - Arrays are preserved for elements that can repeat (e.g., slides, rows)
+ *  - Text content uses '#text' key
+ *  - CDATA sections are preserved
+ *  - XML namespaces (a:, p:, r:, etc.) are preserved as-is
+ *
+ * OpenXML namespace prefixes you'll see:
+ *  a:  — DrawingML (shapes, fonts, colors)
+ *  p:  — PresentationML (slides, layouts, masters)
+ *  r:  — Relationships (rId references)
+ *  c:  — ChartML (chart data)
+ *  w:  — WordprocessingML (not typically in PPTX)
+ *  mc: — Markup Compatibility
+ */
+
+import { XMLParser as FastXMLParser, XMLBuilder } from 'fast-xml-parser';
+import { createLogger } from '../utils/logger.js';
+import { PPTXError } from '../utils/errors.js';
+
+const logger = createLogger('XMLParser');
+
+/**
+ * Parser configuration for fast-xml-parser.
+ * These settings ensure lossless round-trip XML parsing.
+ */
+const PARSER_OPTIONS = {
+  ignoreAttributes: false,
+  ignoreDeclaration: true,
+  attributeNamePrefix: '@_',
+  allowBooleanAttributes: true,
+  parseAttributeValue: false, // Keep all values as strings to avoid type coercion
+  parseTagValue: false,
+  cdataPropName: '__cdata',
+  commentPropName: '__comment',
+  preserveOrder: false,
+  trimValues: false,
+  processEntities: true,
+  htmlEntities: false,
+  isArray: (name, jpath) => {
+    // Elements that should ALWAYS be arrays (even when there's only one)
+    const alwaysArrayPaths = [
+      'p:sld.p:cSld.p:spTree.p:sp',
+      'p:sld.p:cSld.p:spTree.p:pic',
+      'p:sld.p:cSld.p:spTree.p:graphicFrame',
+      'p:sld.p:cSld.p:spTree.p:grpSp',
+      'p:sldMaster.p:sldLayoutIdLst.p:sldLayoutId',
+      'p:presentation.p:sldMasterIdLst.p:sldMasterId',
+      'p:presentation.p:sldIdLst.p:sldId',
+      'a:tbl.a:tr',
+      'a:tr.a:tc',
+      'c:ser',
+      'c:pt',
+      'c:cat.c:strRef.c:strCache.c:pt',
+      'c:val.c:numRef.c:numCache.c:pt',
+      'p:sp',
+      'p:pic',
+      'a:r', // text runs
+      'Relationship',
+      'Override',
+      'Default',
+      'p14:sldId',
+      'p14:section',
+    ];
+    return alwaysArrayPaths.some(path => jpath.endsWith(path) || name === path.split('.').pop());
+  },
+};
+
+/**
+ * Builder configuration for XMLBuilder.
+ * Must match the parser configuration for correct round-trip.
+ */
+const BUILDER_OPTIONS = {
+  ignoreAttributes: false,
+  ignoreDeclaration: true,
+  attributeNamePrefix: '@_',
+  cdataPropName: '__cdata',
+  commentPropName: '__comment',
+  suppressEmptyNode: false,
+  format: false, // No extra whitespace — PPTX is sensitive to whitespace in some cases
+  processEntities: true,
+};
+
+/**
+ * @class XMLParser
+ * @description Provides XML parsing and serialization with OpenXML-aware configuration.
+ */
+export class XMLParser {
+  /**
+   * @private
+   * @type {FastXMLParser}
+   */
+  #parser;
+
+  /**
+   * @private
+   * @type {XMLBuilder}
+   */
+  #builder;
+
+  constructor() {
+    this.#parser = new FastXMLParser(PARSER_OPTIONS);
+    this.#builder = new XMLBuilder(BUILDER_OPTIONS);
+  }
+
+  /**
+   * Parses an XML string into a JavaScript object.
+   * The resulting object preserves all attributes, namespaces, and structure.
+   *
+   * @param {string} xmlString - Raw XML content.
+   * @param {string} [context] - Optional context description for error messages.
+   * @returns {Object} Parsed JavaScript object.
+   * @throws {PPTXError} If XML is malformed.
+   *
+   * @example
+   * const obj = parser.parse('<p:sp><p:nvSpPr>...</p:nvSpPr></p:sp>');
+   */
+  parse(xmlString, context = '') {
+    if (!xmlString || typeof xmlString !== 'string') {
+      throw new PPTXError(`Invalid XML input${context ? ` (${context})` : ''}`);
+    }
+
+    try {
+      return this.#parser.parse(xmlString);
+    } catch (err) {
+      throw new PPTXError(`XML parse error${context ? ` in ${context}` : ''}: ${err.message}`, err);
+    }
+  }
+
+  /**
+   * Serializes a JavaScript object back to an XML string.
+   *
+   * @param {Object} obj - JavaScript object (from parse() or manually constructed).
+   * @param {string} [xmlDeclaration] - Optional XML declaration to prepend.
+   * @returns {string} XML string.
+   *
+   * @example
+   * const xml = parser.build(obj, '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>');
+   */
+  build(obj, xmlDeclaration = '') {
+    try {
+      const xml = this.#builder.build(obj);
+      return xmlDeclaration ? `${xmlDeclaration}\n${xml}` : xml;
+    } catch (err) {
+      throw new PPTXError(`XML build error: ${err.message}`, err);
+    }
+  }
+
+  /**
+   * Extracts the XML declaration line from an XML string.
+   *
+   * @param {string} xmlString - Raw XML string.
+   * @returns {string} Declaration line or empty string.
+   */
+  extractDeclaration(xmlString) {
+    const match = xmlString.match(/^<\?xml[^>]+\?>/);
+    return match ? match[0] : '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+  }
+
+  /**
+   * Performs a deep clone of a parsed XML object.
+   * Used when copying slides to avoid shared object references.
+   *
+   * @param {Object} obj - Object to clone.
+   * @returns {Object} Deep clone.
+   */
+  deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+  }
+
+  /**
+   * Finds all nodes matching a key path in a parsed XML object.
+   * Uses a simple dot-notation path (e.g., 'p:sp.p:txBody.a:p.a:r').
+   *
+   * @param {Object} obj - Root object to search.
+   * @param {string} path - Dot-separated key path.
+   * @returns {Array} Array of matching nodes.
+   *
+   * @example
+   * const runs = parser.findAll(slideObj, 'p:cSld.p:spTree.p:sp.p:txBody.a:p.a:r');
+   */
+  findAll(obj, path) {
+    const keys = path.split('.');
+    let current = [obj];
+
+    for (const key of keys) {
+      const next = [];
+      for (const node of current) {
+        if (node && typeof node === 'object') {
+          const val = node[key];
+          if (Array.isArray(val)) {
+            next.push(...val);
+          } else if (val !== undefined) {
+            next.push(val);
+          }
+        }
+      }
+      current = next;
+    }
+
+    return current;
+  }
+
+  /**
+   * Gets a single node by path (returns first match).
+   *
+   * @param {Object} obj - Root object to search.
+   * @param {string} path - Dot-separated key path.
+   * @returns {*} First matching node or undefined.
+   */
+  getNode(obj, path) {
+    return this.findAll(obj, path)[0];
+  }
+
+  /**
+   * Sets a value at a dot-notation path in an object, creating intermediate
+   * objects as needed.
+   *
+   * @param {Object} obj - Root object.
+   * @param {string} path - Dot-separated key path.
+   * @param {*} value - Value to set.
+   */
+  setNode(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!current[key] || typeof current[key] !== 'object') {
+        current[key] = {};
+      }
+      current = Array.isArray(current[key]) ? current[key][0] : current[key];
+    }
+
+    current[keys[keys.length - 1]] = value;
+  }
+
+  /**
+   * Performs a string replacement directly on the raw XML string.
+   * Faster than parse → modify → build for simple text replacements.
+   *
+   * @param {string} xmlString - Raw XML.
+   * @param {string} search - Substring to find.
+   * @param {string} replace - Replacement string.
+   * @param {boolean} [all=true] - Replace all occurrences or just first.
+   * @returns {string} Modified XML string.
+   */
+  replaceInXml(xmlString, search, replace, all = true) {
+    const escaped = search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const flags = all ? 'g' : '';
+    return xmlString.replace(new RegExp(escaped, flags), replace);
+  }
+
+  /**
+   * Extracts all text content from a slide XML string.
+   * Useful for debugging or searching slide content.
+   *
+   * @param {string} xmlString - Slide XML content.
+   * @returns {string[]} Array of text strings found in the slide.
+   */
+  extractTextContent(xmlString) {
+    const texts = [];
+    const textPattern = /<a:t>([^<]*)<\/a:t>/g;
+    let match;
+    while ((match = textPattern.exec(xmlString)) !== null) {
+      if (match[1].trim()) texts.push(match[1]);
+    }
+    return texts;
+  }
+
+  /**
+   * Validates that an XML string is well-formed.
+   *
+   * @param {string} xmlString - XML to validate.
+   * @returns {{ valid: boolean, error: string|null }}
+   */
+  validate(xmlString) {
+    try {
+      this.parse(xmlString);
+      return { valid: true, error: null };
+    } catch (err) {
+      return { valid: false, error: err.message };
+    }
+  }
+}