d1s 0.2.10 → 0.2.12

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

@@ -1,200 +0,0 @@
-// 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

@@ -1,24 +0,0 @@
-// 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

@@ -1,106 +0,0 @@
-// schema-operations.js
-
-import { executeSQL, ErrorTypes } from './sql-operations.js';
-import logger from './logger.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) {
-    logger.error('Failed to get current schema:', 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

@@ -1,14 +0,0 @@
-// 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'
- };