d1s 0.2.1

package/src/lib/parse-sql-error.js

@@ -0,0 +1,200 @@
+// lib/parse-sql-error.js
+
+import { SQLErrorTypes } from './sql-error-types';
+
+export function parseSQLError(error) {
+  console.debug("parseSQLError - Received error:", error);
+
+  // Defensive check in case error is null/undefined
+  if (!error) {
+    console.debug("parseSQLError - error is null or undefined.");
+    return {
+      type: SQLErrorTypes.UNKNOWN_ERROR,
+      message: 'An unknown error occurred',
+      details: {}
+    };
+  }
+
+  let errorMessage = '';
+  let offset = null;
+  let nearText = null;
+  let originalQuery = null;
+
+  // Determine the command string (it might be on error.cmd or error.details.command)
+  const cmd = error.cmd || (error.details && error.details.command);
+  if (cmd) {
+    const queryMatch = cmd.match(/--command="(.+?)"/s);
+    if (queryMatch) {
+      originalQuery = queryMatch[1].replace(/\\n/g, '\n');
+      console.debug("parseSQLError - Extracted original query:", originalQuery);
+    }
+  }
+
+  // Determine stderr from either error.stderr or error.details.stderr
+  const rawStderr = error.stderr || (error.details && error.details.stderr);
+  if (rawStderr) {
+    // Remove ANSI escape codes
+    const cleanStderr = rawStderr.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+    console.debug("parseSQLError - Cleaned stderr:", cleanStderr);
+
+    // Check for "env: node: No such file or directory" error
+    if (cleanStderr.includes('env: node: No such file or directory')) {
+      console.debug("parseSQLError - Detected 'env: node: No such file or directory' error.");
+      return {
+        type: SQLErrorTypes.EXECUTION_ERROR,
+        message: error.message || 'Execution error: env: node: No such file or directory',
+        details: {
+          originalQuery,
+          stderr: cleanStderr
+        }
+      };
+    }
+
+    // Syntax errors
+    const syntaxMatch = cleanStderr.match(/near "([^"]+)": syntax error at offset (\d+)/);
+    if (syntaxMatch) {
+      const [_, near, errorOffset] = syntaxMatch;
+      offset = parseInt(errorOffset, 10);
+      errorMessage = `Syntax error near "${near}" at position ${offset}`;
+      console.debug("parseSQLError - Syntax error detected:", { near, offset });
+      return {
+        type: SQLErrorTypes.SYNTAX_ERROR,
+        message: errorMessage,
+        details: {
+          originalQuery,
+          errorLocation: { offset, near },
+          stderr: cleanStderr
+        }
+      };
+    }
+
+    // UNIQUE constraint error
+    if (cleanStderr.includes('UNIQUE constraint failed')) {
+      const match = cleanStderr.match(/UNIQUE constraint failed: (\w+)\.(\w+)/);
+      const [_, table, column] = match || [];
+      console.debug("parseSQLError - UNIQUE constraint error detected:", { table, column });
+      return {
+        type: SQLErrorTypes.UNIQUE_CONSTRAINT_ERROR,
+        message: `Unique constraint violation updating ${table}.${column}`,
+        details: {
+          originalQuery,
+          stderr: cleanStderr
+        }
+      };
+    }
+
+    // NOT NULL constraint error
+    if (cleanStderr.includes('NOT NULL constraint failed')) {
+      const match = cleanStderr.match(/NOT NULL constraint failed: (\w+)\.(\w+)/);
+      const [_, table, column] = match || [];
+      console.debug("parseSQLError - NOT NULL constraint error detected:", { table, column });
+      return {
+        type: SQLErrorTypes.NOT_NULL_CONSTRAINT_ERROR,
+        message: `NOT NULL constraint violation updating ${table}.${column}`,
+        details: {
+          originalQuery,
+          stderr: cleanStderr
+        }
+      };
+    }
+
+    // CHECK constraint error
+    if (cleanStderr.includes('CHECK constraint failed')) {
+      const match = cleanStderr.match(/CHECK constraint failed: (\w+)/);
+      const [_, constraintName] = match || [];
+      console.debug("parseSQLError - CHECK constraint error detected:", { constraintName });
+      return {
+        type: SQLErrorTypes.CHECK_CONSTRAINT_ERROR,
+        message: `Check constraint violation updating ${constraintName}`,
+        details: {
+          originalQuery,
+          stderr: cleanStderr
+        }
+      };
+    }
+
+    // In the FOREIGN KEY constraint section:
+    if (cleanStderr.includes('FOREIGN KEY constraint failed')) {
+      console.debug("parseSQLError - FOREIGN KEY constraint error detected.");
+      
+      // Extract query details from the original command
+      const queryMatch = /--command="([^"]+)"/.exec(cmd || '');
+      const query = queryMatch ? queryMatch[1] : null;
+      
+      // Parse the query to get table and column info
+      let details = {};
+      if (query) {
+        const updateMatch = /UPDATE\s+(\w+)\s+SET\s+(\w+)\s*=/.exec(query);
+        if (updateMatch) {
+          details = {
+            table: updateMatch[1],
+            column: updateMatch[2]
+          };
+        }
+      }
+
+      // Build a descriptive message
+      const message = details.table 
+        ? `Foreign key constraint violation updating ${details.table}.${details.column}`
+        : 'Foreign key constraint violation';
+
+      return {
+        type: SQLErrorTypes.FOREIGN_KEY_ERROR,
+        message,
+        details: {
+          ...details,
+          originalQuery: query,
+          stderr: cleanStderr
+        }
+      };
+    }
+
+    // Table not found
+    if (cleanStderr.includes('no such table')) {
+      const match = cleanStderr.match(/no such table: (\w+)/);
+      const [_, table] = match || [];
+      console.debug("parseSQLError - Table not found error detected:", { table });
+      return {
+        type: SQLErrorTypes.TABLE_NOT_FOUND,
+        message: `Table not found: ${table}`,
+        details: {
+          originalQuery,
+          stderr: cleanStderr
+        }
+      };
+    }
+
+    // Table already exists error
+    if (cleanStderr.includes('already exists')) {
+      const match = cleanStderr.match(/table (\w+) already exists/);
+      const [_, table] = match || [];
+      console.debug("parseSQLError - Table exists error detected:", { table });
+      return {
+        type: SQLErrorTypes.TABLE_EXISTS,
+        message: `Table already exists: ${table}`,
+        details: {
+          originalQuery,
+          stderr: cleanStderr
+        }
+      };
+    }
+
+    // Fallback for execution errors
+    console.debug("parseSQLError - No specific error match found. Using fallback for execution error.");
+    return {
+      type: SQLErrorTypes.EXECUTION_ERROR,
+      message: error.message || 'Failed to execute SQL command',
+      details: {
+        originalQuery,
+        stderr: cleanStderr
+      }
+    };
+  }
+
+  console.debug("parseSQLError - No stderr available; using default error handling.");
+  return {
+    type: SQLErrorTypes.UNKNOWN_ERROR,
+    message: error.message || 'An unknown error occurred',
+    details: {}
+  };
+}

package/src/lib/request-deduplication.js

@@ -0,0 +1,24 @@
+// utils/request-deduplication.js
+const requestCache = new Map();
+
+export function deduplicateRequest(key, requestFn, ttl = 2000) {
+  const existing = requestCache.get(key);
+  if (existing && Date.now() - existing.timestamp < ttl) {
+    return existing.promise;
+  }
+
+  const promise = requestFn();
+  requestCache.set(key, {
+    promise,
+    timestamp: Date.now()
+  });
+
+  // Clean up after request completes
+  promise.finally(() => {
+    setTimeout(() => {
+      requestCache.delete(key);
+    }, ttl);
+  });
+
+  return promise;
+}

package/src/lib/schema-operations.js

@@ -0,0 +1,103 @@
+// schema-operations.js
+import { executeSQL, ErrorTypes } from './sql-operations.js';
+
+/**
+ * Retrieves the current database schema (tables, indexes, triggers),
+ * excluding system tables and the migrations table.
+ *
+ * @param {string} projectDir - The project directory.
+ * @param {string} databaseName - The D1 database name.
+ * @param {object} env - Environment variables.
+ * @param {boolean} remote - Whether to run against remote.
+ * @returns {Promise<Array>} An array of schema objects.
+ */
+export async function getCurrentSchema(projectDir, databaseName, env = {}, remote = false) {
+  const sql = `
+    SELECT name, type, sql
+    FROM sqlite_master
+    WHERE type IN ('table', 'index', 'trigger')
+      AND name NOT LIKE 'sqlite_%'
+      AND name != 'd1_migrations';
+  `;
+  try {
+    const result = await executeSQL(projectDir, databaseName, sql, env, remote);
+    const parsed = JSON.parse(result);
+    return parsed[0]?.results || [];
+  } catch (error) {
+    throw {
+      type: ErrorTypes.EXECUTION_ERROR,
+      message: 'Failed to get current schema',
+      details: {
+        error: error.message,
+        suggestions: ['Check database permissions']
+      }
+    };
+  }
+}
+
+/**
+ * Analyzes dependencies among schema statements.
+ *
+ * @param {Array} statements - An array of schema statements.
+ * @returns {Array} Ordered array of table names based on dependencies.
+ */
+export function analyzeDependencies(statements) {
+  const dependencies = new Map();
+  // Filter out non-DDL operations; we assume DATA_MODIFICATION are not DDL.
+  const relevantStatements = statements.filter(s => s.type !== 'DATA_MODIFICATION');
+  
+  relevantStatements.forEach(stmt => {
+    const tableName = (stmt.name || stmt.tableName).toLowerCase();
+    if (!dependencies.has(tableName)) {
+      dependencies.set(tableName, new Set());
+    }
+    // For table creations, extract foreign key references.
+    if (stmt.type === 'CREATE_TABLE') {
+      const fkMatches = stmt.sql.match(/FOREIGN\s+KEY\s*\([^)]+\)\s+REFERENCES\s+(\w+)/gi);
+      if (fkMatches) {
+        fkMatches.forEach(match => {
+          const referencedTable = match.match(/REFERENCES\s+(\w+)/i)[1].toLowerCase();
+          dependencies.get(tableName).add(referencedTable);
+        });
+      }
+    }
+  });
+  return orderTables(dependencies);
+}
+
+/**
+ * Orders tables based on their dependencies.
+ *
+ * @param {Map} dependencies - Map of table names to sets of dependent table names.
+ * @returns {Array} Ordered list of table names.
+ */
+export function orderTables(dependencies) {
+  const ordered = [];
+  const visited = new Set();
+  const visiting = new Set();
+
+  function visit(table) {
+    if (visiting.has(table)) {
+      throw new Error(`Circular dependency detected for table: ${table}`);
+    }
+    if (visited.has(table)) return;
+    visiting.add(table);
+    const deps = dependencies.get(table) || new Set();
+    for (const dep of deps) {
+      if (!dependencies.has(dep)) {
+        throw new Error(`Missing table dependency: ${dep}`);
+      }
+      visit(dep);
+    }
+    visiting.delete(table);
+    visited.add(table);
+    ordered.push(table);
+  }
+
+  for (const table of dependencies.keys()) {
+    if (!visited.has(table)) {
+      visit(table);
+    }
+  }
+  return ordered;
+}

package/src/lib/sql-error-types.js

@@ -0,0 +1,14 @@
+// lib/sql-error-types.js
+export const SQLErrorTypes = {
+   SYNTAX_ERROR: 'SYNTAX_ERROR',
+   VALIDATION_ERROR: 'VALIDATION_ERROR',
+   EXECUTION_ERROR: 'EXECUTION_ERROR',
+   TABLE_NOT_FOUND: 'TABLE_NOT_FOUND',
+   TABLE_EXISTS: 'TABLE_EXISTS',
+   CONSTRAINT_ERROR: 'CONSTRAINT_ERROR',
+   FOREIGN_KEY_ERROR: 'FOREIGN_KEY_ERROR',
+   UNIQUE_CONSTRAINT_ERROR: 'UNIQUE_CONSTRAINT_ERROR',
+   NOT_NULL_CONSTRAINT_ERROR: 'NOT_NULL_CONSTRAINT_ERROR',
+   CHECK_CONSTRAINT_ERROR: 'CHECK_CONSTRAINT_ERROR',
+   UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+ };