@o2vend/theme-cli 1.0.0

package/src/lib/widget-service.js

@@ -0,0 +1,293 @@
+/**
+ * O2VEND Widget Service
+ * Standalone implementation - copied and adapted from webstore solution
+ * Update manually when webstore solution changes
+ * 
+ * Source: o2vend-webstore/services/widget-service.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const NodeCache = require('node-cache');
+
+/**
+ * Widget Service for O2VEND API
+ * Manages widgets for liquid theming and dynamic content
+ */
+class WidgetService {
+  constructor(apiClient, options = {}) {
+    this.apiClient = apiClient;
+    this.themeName = options.theme || 'default';
+    this.themePath = options.themePath || process.cwd();
+    this.cache = new NodeCache({
+      stdTTL: 300, // 5 minutes cache
+      checkperiod: 60
+    });
+    this.widgetTemplateMap = this.loadWidgetTemplateMap();
+  }
+
+  /**
+   * Load widget template mapping from config
+   * @returns {Object} widget type to template slug map
+   */
+  loadWidgetTemplateMap() {
+    try {
+      // Try to load from CLI config directory first
+      const configPath = path.join(__dirname, '../../config/widget-map.json');
+      if (fs.existsSync(configPath)) {
+        const fileContent = fs.readFileSync(configPath, 'utf8');
+        const map = JSON.parse(fileContent);
+        console.log(`[WidgetService] Loaded widget map with ${Object.keys(map).length} entries`);
+        return map;
+      }
+      console.warn('[WidgetService] Widget map file not found at:', configPath);
+    } catch (error) {
+      console.warn('[WidgetService] Failed to load widget map:', error.message);
+    }
+    return {};
+  }
+
+  /**
+   * Normalize keys recursively from PascalCase to camelCase
+   * @param {*} obj - Object to normalize
+   * @returns {*} Object with normalized keys
+   */
+  normalizeContentKeys(obj) {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.normalizeContentKeys(item));
+    }
+
+    if (typeof obj === 'object') {
+      const normalized = {};
+      for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          const normalizedKey = key.charAt(0).toLowerCase() + key.slice(1);
+          normalized[normalizedKey] = this.normalizeContentKeys(obj[key]);
+          // Keep original PascalCase for compatibility
+          if (key !== normalizedKey) {
+            normalized[key] = normalized[normalizedKey];
+          }
+        }
+      }
+      return normalized;
+    }
+
+    return obj;
+  }
+
+  /**
+   * Normalize widget object
+   * @param {Object} widget
+   * @returns {Object}
+   */
+  normalizeWidget(widget) {
+    if (!widget || typeof widget !== 'object') {
+      return widget;
+    }
+
+    // Normalize widget ID
+    if (!widget.id) {
+      if (widget._id) {
+        widget.id = typeof widget._id === 'object' && widget._id.$oid 
+          ? widget._id.$oid 
+          : String(widget._id);
+      } else if (widget.Id) {
+        widget.id = String(widget.Id);
+      } else if (widget.WidgetInstanceId) {
+        widget.id = String(widget.WidgetInstanceId);
+      } else {
+        widget.id = `${widget.type || 'widget'}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      }
+    } else {
+      widget.id = String(widget.id);
+    }
+
+    // Initialize settings and data
+    if (!widget.settings || typeof widget.settings !== 'object') {
+      widget.settings = {};
+    }
+    
+    if (!widget.data || typeof widget.data !== 'object') {
+      widget.data = widget.payload || {};
+    }
+
+    // Parse widget.content if it's a JSON string
+    let parsedContent = null;
+    if (widget.content) {
+      if (typeof widget.content === 'string') {
+        try {
+          parsedContent = JSON.parse(widget.content);
+          parsedContent = this.normalizeContentKeys(parsedContent);
+        } catch (error) {
+          console.warn(`[WidgetService] Failed to parse widget.content JSON:`, error.message);
+          parsedContent = {};
+        }
+      } else if (typeof widget.content === 'object') {
+        parsedContent = this.normalizeContentKeys(widget.content);
+      }
+    } else {
+      parsedContent = {};
+    }
+
+    // Move Title/Subtitle to settings
+    if (widget.Title && !widget.settings.title) {
+      widget.settings.title = widget.Title;
+    }
+    if (widget.title && !widget.settings.title) {
+      widget.settings.title = widget.title;
+    }
+    if (widget.Subtitle && !widget.settings.subtitle) {
+      widget.settings.subtitle = widget.Subtitle;
+    }
+    if (widget.subtitle && !widget.settings.subtitle) {
+      widget.settings.subtitle = widget.subtitle;
+    }
+
+    // Store content
+    widget.data.content = parsedContent;
+    widget.content = parsedContent; // Legacy support
+
+    // Handle HtmlContent
+    if (widget.htmlContent !== undefined && widget.htmlContent !== null && widget.htmlContent !== '') {
+      widget.data.htmlContent = widget.htmlContent;
+    } else if (widget.HtmlContent !== undefined && widget.HtmlContent !== null && widget.HtmlContent !== '') {
+      widget.data.htmlContent = widget.HtmlContent;
+      widget.htmlContent = widget.HtmlContent;
+    }
+
+    // Set section
+    if (!widget.section) {
+      widget.section = widget.sectionName || widget.area || 'content';
+    }
+    widget.section = String(widget.section || 'content').toLowerCase();
+
+    // Set template path
+    widget.template = this.getTemplateSlug(widget.type);
+    widget.template_path = `widgets/${widget.template}`;
+    widget.handle = `${widget.section}-${widget.template}-${widget.id}`.replace(/\s+/g, '-').toLowerCase();
+
+    return widget;
+  }
+
+  /**
+   * Get template slug for widget type
+   * @param {string} widgetType - Widget type
+   * @returns {string} Template slug
+   */
+  getTemplateSlug(widgetType) {
+    if (!widgetType) return 'default';
+    
+    const slug = this.widgetTemplateMap[widgetType] || 
+                 this.widgetTemplateMap[widgetType + 'Widget'] ||
+                 widgetType.toLowerCase().replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+    
+    return slug;
+  }
+
+  /**
+   * Normalize array of widgets
+   * @param {Array} widgets
+   * @returns {Array}
+   */
+  normalizeWidgetArray(widgets = []) {
+    if (!Array.isArray(widgets)) {
+      return widgets;
+    }
+    
+    const normalized = widgets.map(widget => this.normalizeWidget(widget));
+    
+    // Sort by Position, order, or priority
+    normalized.sort((a, b) => {
+      const positionA = a.Position !== undefined ? a.Position : (a.position !== undefined ? a.position : (a.order || a.priority || 0));
+      const positionB = b.Position !== undefined ? b.Position : (b.position !== undefined ? b.position : (b.order || b.priority || 0));
+      return positionA - positionB;
+    });
+    
+    return normalized;
+  }
+
+  /**
+   * Get widgets by section
+   * @param {string} section - Section name
+   * @param {Object} options - Options (pageId, etc.)
+   * @returns {Promise<Array>} Widgets array
+   */
+  async getWidgetsBySection(section, options = {}) {
+    try {
+      if (!this.apiClient) {
+        // If no API client, return empty array (mock mode will handle)
+        return [];
+      }
+
+      const params = {
+        section,
+        status: 'active',
+        ...options
+      };
+      
+      const response = await this.apiClient.getWidgetsBySection(options.pageId, section);
+      const widgets = Array.isArray(response) ? response : (response.widgets || []);
+      
+      return this.normalizeWidgetArray(widgets);
+    } catch (error) {
+      console.warn(`[WidgetService] Error getting widgets for section ${section}:`, error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Get all widgets organized by section
+   * @param {Object} options - Options (pageId, etc.)
+   * @returns {Promise<Object>} Widgets organized by section
+   */
+  async getWidgetsBySections(options = {}) {
+    try {
+      if (!this.apiClient) {
+        return {};
+      }
+
+      const params = {
+        status: 'active',
+        ...options
+      };
+      
+      const response = await this.apiClient.getWidgets(params);
+      const widgets = Array.isArray(response) ? response : (response.widgets || []);
+      
+      const normalized = this.normalizeWidgetArray(widgets);
+      
+      // Organize by section
+      const widgetsBySection = {};
+      normalized.forEach(widget => {
+        const section = widget.section || 'content';
+        if (!widgetsBySection[section]) {
+          widgetsBySection[section] = [];
+        }
+        widgetsBySection[section].push(widget);
+      });
+      
+      return widgetsBySection;
+    } catch (error) {
+      console.warn('[WidgetService] Error getting widgets:', error.message);
+      return {};
+    }
+  }
+
+  /**
+   * Check if widget template exists in theme
+   * @param {string} widgetType - Widget type
+   * @param {string} themePath - Theme path
+   * @returns {boolean}
+   */
+  widgetTemplateExists(widgetType, themePath = null) {
+    const templateSlug = this.getTemplateSlug(widgetType);
+    const widgetPath = path.join(themePath || this.themePath, 'widgets', `${templateSlug}.liquid`);
+    return fs.existsSync(widgetPath);
+  }
+}
+
+module.exports = WidgetService;