swarm-tickets 1.0.1 → 2.0.0

package/lib/storage/base-adapter.js

@@ -0,0 +1,200 @@
+/**
+ * Base Storage Adapter
+ * Abstract class defining the interface for all storage backends
+ */
+
+class BaseAdapter {
+  constructor(config) {
+    this.config = config;
+    if (new.target === BaseAdapter) {
+      throw new Error('BaseAdapter is abstract and cannot be instantiated directly');
+    }
+  }
+
+  /**
+   * Initialize the storage (create tables, files, etc.)
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    throw new Error('initialize() must be implemented');
+  }
+
+  /**
+   * Close the storage connection
+   * @returns {Promise<void>}
+   */
+  async close() {
+    throw new Error('close() must be implemented');
+  }
+
+  // ==================== TICKET OPERATIONS ====================
+
+  /**
+   * Get all tickets
+   * @param {Object} filters - Optional filters (status, priority, route)
+   * @returns {Promise<Array>} Array of tickets
+   */
+  async getAllTickets(filters = {}) {
+    throw new Error('getAllTickets() must be implemented');
+  }
+
+  /**
+   * Get a single ticket by ID
+   * @param {string} id - Ticket ID
+   * @returns {Promise<Object|null>} Ticket or null if not found
+   */
+  async getTicket(id) {
+    throw new Error('getTicket() must be implemented');
+  }
+
+  /**
+   * Create a new ticket
+   * @param {Object} ticketData - Ticket data
+   * @returns {Promise<Object>} Created ticket with ID
+   */
+  async createTicket(ticketData) {
+    throw new Error('createTicket() must be implemented');
+  }
+
+  /**
+   * Update a ticket
+   * @param {string} id - Ticket ID
+   * @param {Object} updates - Fields to update
+   * @returns {Promise<Object|null>} Updated ticket or null if not found
+   */
+  async updateTicket(id, updates) {
+    throw new Error('updateTicket() must be implemented');
+  }
+
+  /**
+   * Delete a ticket
+   * @param {string} id - Ticket ID
+   * @returns {Promise<boolean>} True if deleted
+   */
+  async deleteTicket(id) {
+    throw new Error('deleteTicket() must be implemented');
+  }
+
+  // ==================== SWARM ACTION OPERATIONS ====================
+
+  /**
+   * Add a swarm action to a ticket
+   * @param {string} ticketId - Ticket ID
+   * @param {Object} action - Action data (action, result)
+   * @returns {Promise<Object>} Updated ticket
+   */
+  async addSwarmAction(ticketId, action) {
+    throw new Error('addSwarmAction() must be implemented');
+  }
+
+  // ==================== COMMENT OPERATIONS ====================
+
+  /**
+   * Add a comment to a ticket
+   * @param {string} ticketId - Ticket ID
+   * @param {Object} comment - Comment data (author, content, type)
+   * @returns {Promise<Object>} Created comment
+   */
+  async addComment(ticketId, comment) {
+    throw new Error('addComment() must be implemented');
+  }
+
+  /**
+   * Get all comments for a ticket
+   * @param {string} ticketId - Ticket ID
+   * @returns {Promise<Array>} Array of comments
+   */
+  async getComments(ticketId) {
+    throw new Error('getComments() must be implemented');
+  }
+
+  /**
+   * Update a comment
+   * @param {string} ticketId - Ticket ID
+   * @param {string} commentId - Comment ID
+   * @param {Object} updates - Fields to update
+   * @returns {Promise<Object|null>} Updated comment or null
+   */
+  async updateComment(ticketId, commentId, updates) {
+    throw new Error('updateComment() must be implemented');
+  }
+
+  /**
+   * Delete a comment
+   * @param {string} ticketId - Ticket ID
+   * @param {string} commentId - Comment ID
+   * @returns {Promise<boolean>} True if deleted
+   */
+  async deleteComment(ticketId, commentId) {
+    throw new Error('deleteComment() must be implemented');
+  }
+
+  // ==================== STATS OPERATIONS ====================
+
+  /**
+   * Get ticket statistics
+   * @returns {Promise<Object>} Statistics object
+   */
+  async getStats() {
+    throw new Error('getStats() must be implemented');
+  }
+
+  // ==================== BUG REPORT OPERATIONS ====================
+
+  /**
+   * Create a bug report (limited access endpoint)
+   * @param {Object} reportData - Bug report data
+   * @param {string} apiKey - Optional API key for validation
+   * @returns {Promise<Object>} Created ticket (limited info)
+   */
+  async createBugReport(reportData, apiKey = null) {
+    throw new Error('createBugReport() must be implemented');
+  }
+
+  // ==================== UTILITY METHODS ====================
+
+  /**
+   * Generate a unique ticket ID
+   * @returns {string} Ticket ID
+   */
+  generateTicketId() {
+    return 'TKT-' + Date.now();
+  }
+
+  /**
+   * Generate a unique comment ID
+   * @returns {string} Comment ID
+   */
+  generateCommentId() {
+    return 'CMT-' + Date.now() + '-' + Math.random().toString(36).substr(2, 9);
+  }
+
+  /**
+   * Validate ticket status
+   * @param {string} status - Status to validate
+   * @returns {boolean} True if valid
+   */
+  isValidStatus(status) {
+    return ['open', 'in-progress', 'fixed', 'closed'].includes(status);
+  }
+
+  /**
+   * Validate ticket priority
+   * @param {string} priority - Priority to validate
+   * @returns {boolean} True if valid
+   */
+  isValidPriority(priority) {
+    return ['critical', 'high', 'medium', 'low'].includes(priority);
+  }
+
+  /**
+   * Create a backup (if supported)
+   * @returns {Promise<string|null>} Backup path or null
+   */
+  async createBackup() {
+    // Default: no backup support
+    return null;
+  }
+}
+
+module.exports = BaseAdapter;

package/lib/storage/index.js

@@ -0,0 +1,87 @@
+/**
+ * Storage Adapter Factory
+ * Supports JSON, SQLite, and Supabase backends
+ */
+
+const JsonAdapter = require('./json-adapter');
+const SqliteAdapter = require('./sqlite-adapter');
+const SupabaseAdapter = require('./supabase-adapter');
+
+/**
+ * Get storage configuration from environment or config file
+ */
+function getStorageConfig() {
+  // Check environment variables first
+  const storageType = process.env.SWARM_TICKETS_STORAGE || 'json';
+
+  const config = {
+    type: storageType,
+    // JSON options
+    jsonPath: process.env.SWARM_TICKETS_JSON_PATH || './tickets.json',
+    backupDir: process.env.SWARM_TICKETS_BACKUP_DIR || './ticket-backups',
+
+    // SQLite options
+    sqlitePath: process.env.SWARM_TICKETS_SQLITE_PATH || './tickets.db',
+
+    // Supabase options
+    supabaseUrl: process.env.SUPABASE_URL || process.env.SWARM_TICKETS_SUPABASE_URL,
+    supabaseKey: process.env.SUPABASE_ANON_KEY || process.env.SWARM_TICKETS_SUPABASE_KEY,
+    supabaseServiceKey: process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.SWARM_TICKETS_SUPABASE_SERVICE_KEY,
+  };
+
+  return config;
+}
+
+/**
+ * Create storage adapter based on configuration
+ * @param {Object} overrideConfig - Optional config override
+ * @returns {Promise<BaseAdapter>} Storage adapter instance
+ */
+async function createStorageAdapter(overrideConfig = null) {
+  const config = overrideConfig || getStorageConfig();
+
+  let adapter;
+
+  switch (config.type.toLowerCase()) {
+    case 'sqlite':
+      adapter = new SqliteAdapter(config);
+      break;
+
+    case 'supabase':
+      if (!config.supabaseUrl || !config.supabaseKey) {
+        throw new Error(
+          'Supabase configuration missing. Set SUPABASE_URL and SUPABASE_ANON_KEY environment variables.'
+        );
+      }
+      adapter = new SupabaseAdapter(config);
+      break;
+
+    case 'json':
+    default:
+      adapter = new JsonAdapter(config);
+      break;
+  }
+
+  // Initialize the adapter (create tables, etc.)
+  await adapter.initialize();
+
+  return adapter;
+}
+
+/**
+ * Storage type constants
+ */
+const StorageType = {
+  JSON: 'json',
+  SQLITE: 'sqlite',
+  SUPABASE: 'supabase'
+};
+
+module.exports = {
+  createStorageAdapter,
+  getStorageConfig,
+  StorageType,
+  JsonAdapter,
+  SqliteAdapter,
+  SupabaseAdapter
+};

package/lib/storage/json-adapter.js

@@ -0,0 +1,293 @@
+/**
+ * JSON File Storage Adapter
+ * Backwards-compatible with existing tickets.json format
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const BaseAdapter = require('./base-adapter');
+
+class JsonAdapter extends BaseAdapter {
+  constructor(config) {
+    super(config);
+    this.ticketsPath = path.resolve(config.jsonPath || './tickets.json');
+    this.backupDir = path.resolve(config.backupDir || './ticket-backups');
+    this.data = { tickets: [] };
+  }
+
+  async initialize() {
+    // Create backup directory
+    try {
+      await fs.mkdir(this.backupDir, { recursive: true });
+    } catch (error) {
+      // Directory may already exist
+    }
+
+    // Load existing data or create new file
+    try {
+      const content = await fs.readFile(this.ticketsPath, 'utf8');
+      this.data = JSON.parse(content);
+      // Ensure tickets array exists
+      if (!this.data.tickets) {
+        this.data.tickets = [];
+      }
+      // Migrate: add comments array to existing tickets
+      this.data.tickets = this.data.tickets.map(ticket => ({
+        ...ticket,
+        comments: ticket.comments || []
+      }));
+    } catch (error) {
+      // File doesn't exist, create empty structure
+      this.data = { tickets: [] };
+      await this._save();
+    }
+  }
+
+  async close() {
+    // No connection to close for file-based storage
+  }
+
+  async _save() {
+    await this.createBackup();
+    await fs.writeFile(this.ticketsPath, JSON.stringify(this.data, null, 2));
+  }
+
+  async createBackup() {
+    try {
+      await fs.access(this.ticketsPath);
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupPath = path.join(this.backupDir, `tickets-${timestamp}.json`);
+      await fs.copyFile(this.ticketsPath, backupPath);
+
+      // Rotate backups - keep last 10
+      const files = await fs.readdir(this.backupDir);
+      const backupFiles = files
+        .filter(f => f.startsWith('tickets-') && f.endsWith('.json'))
+        .sort()
+        .reverse();
+
+      if (backupFiles.length > 10) {
+        for (let i = 10; i < backupFiles.length; i++) {
+          await fs.unlink(path.join(this.backupDir, backupFiles[i]));
+        }
+      }
+
+      return backupPath;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // ==================== TICKET OPERATIONS ====================
+
+  async getAllTickets(filters = {}) {
+    let tickets = [...this.data.tickets];
+
+    if (filters.status) {
+      tickets = tickets.filter(t => t.status === filters.status);
+    }
+    if (filters.priority) {
+      tickets = tickets.filter(t => t.priority === filters.priority);
+    }
+    if (filters.route) {
+      tickets = tickets.filter(t => t.route && t.route.includes(filters.route));
+    }
+
+    return tickets;
+  }
+
+  async getTicket(id) {
+    return this.data.tickets.find(t => t.id === id) || null;
+  }
+
+  async createTicket(ticketData) {
+    const ticket = {
+      id: this.generateTicketId(),
+      route: ticketData.route || '',
+      f12Errors: ticketData.f12Errors || '',
+      serverErrors: ticketData.serverErrors || '',
+      description: ticketData.description || '',
+      status: ticketData.status || 'open',
+      priority: ticketData.priority || null,
+      relatedTickets: ticketData.relatedTickets || [],
+      swarmActions: ticketData.swarmActions || [],
+      comments: ticketData.comments || [],
+      namespace: ticketData.namespace || null,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+
+    this.data.tickets.push(ticket);
+    await this._save();
+
+    return ticket;
+  }
+
+  async updateTicket(id, updates) {
+    const ticketIndex = this.data.tickets.findIndex(t => t.id === id);
+    if (ticketIndex === -1) return null;
+
+    const allowedFields = [
+      'status', 'priority', 'relatedTickets', 'swarmActions',
+      'namespace', 'description', 'f12Errors', 'serverErrors', 'route', 'comments'
+    ];
+
+    const ticket = this.data.tickets[ticketIndex];
+
+    allowedFields.forEach(field => {
+      if (updates[field] !== undefined) {
+        ticket[field] = updates[field];
+      }
+    });
+
+    ticket.updatedAt = new Date().toISOString();
+    await this._save();
+
+    return ticket;
+  }
+
+  async deleteTicket(id) {
+    const ticketIndex = this.data.tickets.findIndex(t => t.id === id);
+    if (ticketIndex === -1) return false;
+
+    this.data.tickets.splice(ticketIndex, 1);
+    await this._save();
+
+    return true;
+  }
+
+  // ==================== SWARM ACTION OPERATIONS ====================
+
+  async addSwarmAction(ticketId, action) {
+    const ticket = await this.getTicket(ticketId);
+    if (!ticket) return null;
+
+    const swarmAction = {
+      timestamp: new Date().toISOString(),
+      action: action.action,
+      result: action.result || null
+    };
+
+    ticket.swarmActions.push(swarmAction);
+    ticket.updatedAt = new Date().toISOString();
+
+    await this._save();
+    return ticket;
+  }
+
+  // ==================== COMMENT OPERATIONS ====================
+
+  async addComment(ticketId, commentData) {
+    const ticket = await this.getTicket(ticketId);
+    if (!ticket) return null;
+
+    // Ensure comments array exists
+    if (!ticket.comments) {
+      ticket.comments = [];
+    }
+
+    const comment = {
+      id: this.generateCommentId(),
+      timestamp: new Date().toISOString(),
+      type: commentData.type || 'human', // 'human' or 'ai'
+      author: commentData.author || 'anonymous',
+      content: commentData.content || '',
+      metadata: commentData.metadata || {}
+    };
+
+    ticket.comments.push(comment);
+    ticket.updatedAt = new Date().toISOString();
+
+    await this._save();
+    return comment;
+  }
+
+  async getComments(ticketId) {
+    const ticket = await this.getTicket(ticketId);
+    if (!ticket) return [];
+    return ticket.comments || [];
+  }
+
+  async updateComment(ticketId, commentId, updates) {
+    const ticket = await this.getTicket(ticketId);
+    if (!ticket || !ticket.comments) return null;
+
+    const commentIndex = ticket.comments.findIndex(c => c.id === commentId);
+    if (commentIndex === -1) return null;
+
+    const comment = ticket.comments[commentIndex];
+    if (updates.content !== undefined) comment.content = updates.content;
+    if (updates.metadata !== undefined) comment.metadata = { ...comment.metadata, ...updates.metadata };
+    comment.editedAt = new Date().toISOString();
+
+    ticket.updatedAt = new Date().toISOString();
+    await this._save();
+
+    return comment;
+  }
+
+  async deleteComment(ticketId, commentId) {
+    const ticket = await this.getTicket(ticketId);
+    if (!ticket || !ticket.comments) return false;
+
+    const commentIndex = ticket.comments.findIndex(c => c.id === commentId);
+    if (commentIndex === -1) return false;
+
+    ticket.comments.splice(commentIndex, 1);
+    ticket.updatedAt = new Date().toISOString();
+    await this._save();
+
+    return true;
+  }
+
+  // ==================== STATS OPERATIONS ====================
+
+  async getStats() {
+    const tickets = this.data.tickets;
+
+    return {
+      total: tickets.length,
+      byStatus: {
+        open: tickets.filter(t => t.status === 'open').length,
+        inProgress: tickets.filter(t => t.status === 'in-progress').length,
+        fixed: tickets.filter(t => t.status === 'fixed').length,
+        closed: tickets.filter(t => t.status === 'closed').length
+      },
+      byPriority: {
+        critical: tickets.filter(t => t.priority === 'critical').length,
+        high: tickets.filter(t => t.priority === 'high').length,
+        medium: tickets.filter(t => t.priority === 'medium').length,
+        low: tickets.filter(t => t.priority === 'low').length
+      }
+    };
+  }
+
+  // ==================== BUG REPORT OPERATIONS ====================
+
+  async createBugReport(reportData, apiKey = null) {
+    // For JSON adapter, we don't validate API keys (simple mode)
+    // Create a minimal ticket from the bug report
+    const ticket = await this.createTicket({
+      route: reportData.location || reportData.route || 'unknown',
+      f12Errors: reportData.clientError || reportData.f12Errors || '',
+      serverErrors: '', // Bug reports don't include server errors
+      description: reportData.description || '',
+      status: 'open',
+      priority: null, // Will be set by triage
+      swarmActions: [{
+        timestamp: new Date().toISOString(),
+        action: 'bug-report-submitted',
+        result: `Bug report submitted via widget. User agent: ${reportData.userAgent || 'unknown'}`
+      }]
+    });
+
+    // Return limited info (don't expose internal ticket structure)
+    return {
+      id: ticket.id,
+      status: 'submitted',
+      message: 'Bug report received. Thank you!'
+    };
+  }
+}
+
+module.exports = JsonAdapter;