@rapidd/build 1.0.0

package/src/parsers/advancedRLSConverter.js

@@ -0,0 +1,305 @@
+/**
+ * Advanced PostgreSQL RLS to JavaScript/Prisma Converter
+ * Handles real production PostgreSQL RLS patterns with custom functions
+ */
+
+/**
+ * Main converter function - PostgreSQL RLS to JavaScript
+ */
+function convertToJavaScript(sql, dataVar = 'data', userVar = 'user') {
+  if (!sql || sql.trim() === '') {
+    return 'true';
+  }
+
+  sql = sql.trim();
+
+  // Remove extra whitespace and newlines for consistent parsing
+  sql = sql.replace(/\s+/g, ' ').replace(/\n/g, ' ');
+
+  // Handle CASE WHEN expressions
+  if (sql.toUpperCase().startsWith('CASE')) {
+    return convertCaseWhen(sql, dataVar, userVar);
+  }
+
+  // Handle combined conditions with OR
+  const orMatch = sql.match(/\((.*?)\)\s+OR\s+\((.*?)\)/i);
+  if (orMatch) {
+    const left = convertToJavaScript(orMatch[1], dataVar, userVar);
+    const right = convertToJavaScript(orMatch[2], dataVar, userVar);
+    return `(${left} || ${right})`;
+  }
+
+  // Handle role checks: get_current_user_role() = ANY (ARRAY[...])
+  if (sql.includes('get_current_user_role')) {
+    return convertRoleCheck(sql, userVar);
+  }
+
+  // Handle field comparisons with custom functions
+  const customFuncPatterns = [
+    { pattern: /teacher_id\s*=\s*get_current_teacher_id\(\)/i, replacement: `${dataVar}?.teacher_id === ${userVar}?.teacher_id` },
+    { pattern: /student_id\s*=\s*get_current_student_id\(\)/i, replacement: `${dataVar}?.student_id === ${userVar}?.student_id` },
+    { pattern: /user_id\s*=\s*\(\s*current_setting\s*\(\s*'app\.current_user_id'[^)]*\)[^)]*\)/i, replacement: `${dataVar}?.user_id === ${userVar}?.id` },
+    { pattern: /id\s*=\s*\(\s*current_setting\s*\(\s*'app\.current_user_id'[^)]*\)[^)]*\)/i, replacement: `${dataVar}?.id === ${userVar}?.id` },
+    { pattern: /(\w+)\s*=\s*get_current_teacher_id\(\)/i, replacement: (m) => `${dataVar}?.${m[1]} === ${userVar}?.teacher_id` },
+    { pattern: /(\w+)\s*=\s*get_current_student_id\(\)/i, replacement: (m) => `${dataVar}?.${m[1]} === ${userVar}?.student_id` }
+  ];
+
+  for (const { pattern, replacement } of customFuncPatterns) {
+    if (pattern.test(sql)) {
+      if (typeof replacement === 'function') {
+        const match = sql.match(pattern);
+        return replacement(match);
+      }
+      return replacement;
+    }
+  }
+
+  // Handle EXISTS subqueries
+  if (sql.includes('EXISTS')) {
+    return convertExistsSubquery(sql, dataVar, userVar);
+  }
+
+  // Fallback for unhandled patterns
+  return `true /* Complex RLS expression: ${sql.substring(0, 80)}... */`;
+}
+
+/**
+ * Convert role check expressions
+ */
+function convertRoleCheck(sql, userVar) {
+  // Extract roles from ARRAY[...] pattern
+  const arrayMatch = sql.match(/ARRAY\s*\[([^\]]+)\]/i);
+  if (arrayMatch) {
+    const roles = arrayMatch[1]
+      .split(',')
+      .map(r => r.trim())
+      .map(r => r.replace(/::[^,\]]+/g, '')) // Remove type casts (including "character varying")
+      .map(r => r.replace(/^'|'$/g, '')) // Remove quotes
+      .map(r => `'${r}'`)
+      .join(', ');
+    return `[${roles}].includes(${userVar}?.role)`;
+  }
+
+  // Simple role equality
+  const simpleMatch = sql.match(/get_current_user_role\(\)[^=]*=\s*'([^']+)'/i);
+  if (simpleMatch) {
+    return `${userVar}?.role === '${simpleMatch[1]}'`;
+  }
+
+  return `true /* Unparseable role check */`;
+}
+
+/**
+ * Convert CASE WHEN expressions
+ */
+function convertCaseWhen(sql, dataVar, userVar) {
+  // Extract the CASE expression and branches
+  const caseMatch = sql.match(/CASE\s+(\S+(?:\([^)]*\))?)\s+((?:WHEN[\s\S]+?)+)\s*(?:ELSE\s+([\s\S]+?))?\s*END/i);
+
+  if (!caseMatch) {
+    return `false /* Unparseable CASE expression */`;
+  }
+
+  const caseExpr = caseMatch[1];
+  const whenClauses = caseMatch[2];
+  const elseClause = caseMatch[3];
+
+  // Determine what's being tested
+  let testExpr = '';
+  if (caseExpr.includes('get_current_user_role')) {
+    testExpr = `${userVar}?.role`;
+  } else if (caseExpr.includes('get_current_teacher_id')) {
+    testExpr = `${userVar}?.teacher_id`;
+  } else if (caseExpr.includes('get_current_student_id')) {
+    testExpr = `${userVar}?.student_id`;
+  } else {
+    return `false /* Unsupported CASE expression: ${caseExpr} */`;
+  }
+
+  // Parse WHEN branches
+  const whenPattern = /WHEN\s+'?([^':\s]+)'?(?:::\w+)?\s+THEN\s+((?:(?!WHEN\s+|ELSE\s+|END).)+)/gi;
+  const conditions = [];
+
+  let match;
+  while ((match = whenPattern.exec(whenClauses)) !== null) {
+    const value = match[1];
+    const thenExpr = match[2].trim();
+
+    if (thenExpr.toLowerCase() === 'true') {
+      conditions.push(`${testExpr} === '${value}'`);
+    } else if (thenExpr.toLowerCase() === 'false') {
+      // Skip false conditions
+    } else {
+      // Complex THEN expression
+      const convertedThen = convertThenExpression(thenExpr, dataVar, userVar);
+      if (convertedThen !== 'false') {
+        conditions.push(`(${testExpr} === '${value}' && ${convertedThen})`);
+      }
+    }
+  }
+
+  // Handle ELSE clause
+  if (elseClause && elseClause.trim().toLowerCase() === 'true') {
+    conditions.push('true');
+  }
+
+  return conditions.length > 0 ? conditions.join(' || ') : 'false';
+}
+
+/**
+ * Convert THEN expressions in CASE WHEN
+ */
+function convertThenExpression(expr, dataVar, userVar) {
+  expr = expr.trim();
+
+  // Remove parentheses
+  if (expr.startsWith('(') && expr.endsWith(')')) {
+    expr = expr.substring(1, expr.length - 1).trim();
+  }
+
+  // Handle EXISTS
+  if (expr.includes('EXISTS')) {
+    return convertExistsSubquery(expr, dataVar, userVar);
+  }
+
+  // Handle field = function() patterns
+  const patterns = [
+    { regex: /teacher_id\s*=\s*get_current_teacher_id\(\)/i, js: `${dataVar}?.teacher_id === ${userVar}?.teacher_id` },
+    { regex: /student_id\s*=\s*get_current_student_id\(\)/i, js: `${dataVar}?.student_id === ${userVar}?.student_id` },
+    { regex: /id\s*=\s*\(\s*current_setting\s*\(\s*'app\.current_user_id'[^)]*\)[^)]*\)/i, js: `${dataVar}?.id === ${userVar}?.id` },
+    { regex: /(\w+)\s*=\s*get_current_(\w+)_id\(\)/i, handler: (m) => `${dataVar}?.${m[1]} === ${userVar}?.${m[2]}_id` }
+  ];
+
+  for (const pattern of patterns) {
+    if (pattern.regex.test(expr)) {
+      if (pattern.handler) {
+        const match = expr.match(pattern.regex);
+        return pattern.handler(match);
+      }
+      return pattern.js;
+    }
+  }
+
+  return 'true';
+}
+
+/**
+ * Convert EXISTS subqueries to JavaScript
+ * These typically check relationships between tables
+ */
+function convertExistsSubquery(sql, dataVar, userVar) {
+  // Common patterns in EXISTS subqueries
+
+  // Pattern 1: Check if student_tariff belongs to current student
+  if (sql.includes('student_tariff') && sql.includes('get_current_student_id')) {
+    return `true /* TODO: Check if ${dataVar}?.student_tariff.student_id === ${userVar}?.student_id */`;
+  }
+
+  // Pattern 2: Check if teacher has access
+  if (sql.includes('get_current_teacher_id')) {
+    return `true /* TODO: Check if ${dataVar} is accessible to teacher ${userVar}?.teacher_id */`;
+  }
+
+  // Pattern 3: Check user address relationships
+  if (sql.includes('contact_address_id') || sql.includes('billing_address_id')) {
+    return `true /* TODO: Check if address belongs to user via contact_address_id or billing_address_id */`;
+  }
+
+  // Pattern 4: Generic student access check
+  if (sql.includes('student') && sql.includes('get_current_student_id')) {
+    return `true /* TODO: Check student relationship */`;
+  }
+
+  // Default EXISTS handling
+  return `true /* EXISTS subquery requires manual implementation */`;
+}
+
+/**
+ * Convert to Prisma filter
+ */
+function convertToPrismaFilter(sql, userVar = 'user') {
+  if (!sql || sql.trim() === '') {
+    return '{}';
+  }
+
+  sql = sql.trim().replace(/\s+/g, ' ').replace(/\n/g, ' ');
+
+  // Role-based filters can't be directly applied in Prisma WHERE clause
+  if (sql.includes('get_current_user_role')) {
+    return '{}'; // Role checks are done in hasAccess, not in filter
+  }
+
+  // Handle CASE WHEN - extract filterable conditions
+  if (sql.toUpperCase().startsWith('CASE')) {
+    return convertCaseWhenToPrisma(sql, userVar);
+  }
+
+  // Handle simple field comparisons
+  const patterns = [
+    { regex: /teacher_id\s*=\s*get_current_teacher_id\(\)/i, filter: `{ teacher_id: ${userVar}?.teacher_id }` },
+    { regex: /student_id\s*=\s*get_current_student_id\(\)/i, filter: `{ student_id: ${userVar}?.student_id }` },
+    { regex: /user_id\s*=\s*\(\s*current_setting\s*\(\s*'app\.current_user_id'/i, filter: `{ user_id: ${userVar}?.id }` },
+    { regex: /^id\s*=\s*\(\s*current_setting\s*\(\s*'app\.current_user_id'/i, filter: `{ id: ${userVar}?.id }` }
+  ];
+
+  for (const pattern of patterns) {
+    if (pattern.regex.test(sql)) {
+      return pattern.filter;
+    }
+  }
+
+  // Handle OR conditions
+  const orMatch = sql.match(/\((.*?)\)\s+OR\s+\((.*?)\)/i);
+  if (orMatch) {
+    const left = convertToPrismaFilter(orMatch[1], userVar);
+    const right = convertToPrismaFilter(orMatch[2], userVar);
+    if (left !== '{}' && right !== '{}') {
+      return `{ OR: [${left}, ${right}] }`;
+    } else if (left !== '{}') {
+      return left;
+    } else if (right !== '{}') {
+      return right;
+    }
+  }
+
+  return '{}';
+}
+
+/**
+ * Convert CASE WHEN to Prisma filter
+ */
+function convertCaseWhenToPrisma(sql, userVar) {
+  // Extract field-based conditions that can be filtered in Prisma
+  const filters = [];
+
+  // Look for teacher_id = get_current_teacher_id()
+  if (sql.includes('teacher_id') && sql.includes('get_current_teacher_id')) {
+    filters.push(`{ teacher_id: ${userVar}?.teacher_id }`);
+  }
+
+  // Look for student_id = get_current_student_id()
+  if (sql.includes('student_id') && sql.includes('get_current_student_id')) {
+    filters.push(`{ student_id: ${userVar}?.student_id }`);
+  }
+
+  // Look for id = current_setting('app.current_user_id')
+  if (sql.match(/id\s*=\s*\(\s*current_setting\s*\(\s*'app\.current_user_id'/i)) {
+    filters.push(`{ id: ${userVar}?.id }`);
+  }
+
+  if (filters.length === 0) {
+    return '{}';
+  }
+
+  if (filters.length === 1) {
+    return filters[0];
+  }
+
+  // Multiple conditions are OR'd in CASE WHEN
+  return `{ OR: [${filters.join(', ')}] }`;
+}
+
+module.exports = {
+  convertToJavaScript,
+  convertToPrismaFilter
+};

package/src/parsers/autoRLSConverter.js

@@ -0,0 +1,322 @@
+/**
+ * Automatic PostgreSQL RLS to JavaScript Converter
+ * Uses dynamic function analysis - no hardcoding!
+ */
+
+/**
+ * Create a converter with analyzed function mappings
+ */
+function createConverter(functionMappings = {}, sessionVariables = {}) {
+
+  /**
+   * Convert PostgreSQL RLS to JavaScript
+   */
+  function convertToJavaScript(sql, dataVar = 'data', userVar = 'user') {
+    if (!sql || sql.trim() === '') {
+      return 'true';
+    }
+
+    sql = sql.trim().replace(/\s+/g, ' ').replace(/\n/g, ' ');
+
+    // Handle CASE WHEN
+    if (sql.toUpperCase().startsWith('CASE')) {
+      return convertCaseWhen(sql, dataVar, userVar);
+    }
+
+    // Handle OR
+    const orParts = splitLogicalOperator(sql, 'OR');
+    if (orParts.length > 1) {
+      return orParts.map(part => convertToJavaScript(part, dataVar, userVar)).join(' || ');
+    }
+
+    // Handle AND
+    const andParts = splitLogicalOperator(sql, 'AND');
+    if (andParts.length > 1) {
+      return '(' + andParts.map(part => convertToJavaScript(part, dataVar, userVar)).join(' && ') + ')';
+    }
+
+    // Handle function = ANY (ARRAY[...])
+    const funcAnyMatch = sql.match(/(\w+)\s*\([^)]*\)[^=]*=\s*ANY\s*\(\s*(?:\()?ARRAY\s*\[([^\]]+)\]/i);
+    if (funcAnyMatch) {
+      const funcName = funcAnyMatch[1];
+      const arrayValues = extractArrayValues(funcAnyMatch[2]);
+
+      // Use analyzed mapping or fallback
+      const jsExpression = getFunctionMapping(funcName, userVar);
+      return `[${arrayValues}].includes(${jsExpression})`;
+    }
+
+    // Handle function() = 'value' (e.g., get_current_user_role() = 'admin')
+    const funcValueMatch = sql.match(/(\w+)\s*\([^)]*\)\s*=\s*'([^']+)'/i);
+    if (funcValueMatch) {
+      const funcName = funcValueMatch[1];
+      const value = funcValueMatch[2];
+
+      const jsExpression = getFunctionMapping(funcName, userVar);
+      return `${jsExpression} === '${value}'`;
+    }
+
+    // Handle field = function()
+    const fieldFuncMatch = sql.match(/(\w+)\s*=\s*(\w+)\s*\([^)]*\)/i);
+    if (fieldFuncMatch) {
+      const field = fieldFuncMatch[1];
+      const funcName = fieldFuncMatch[2];
+
+      const jsExpression = getFunctionMapping(funcName, userVar);
+      return `${dataVar}?.${field} === ${jsExpression}`;
+    }
+
+    // Handle current_setting
+    const settingMatch = sql.match(/(\w+)\s*=\s*\(\s*current_setting\s*\(\s*'([^']+)'/i);
+    if (settingMatch) {
+      const field = settingMatch[1];
+      const setting = settingMatch[2];
+
+      const jsExpression = getSessionMapping(setting, userVar);
+      return `${dataVar}?.${field} === ${jsExpression}`;
+    }
+
+    // Handle EXISTS
+    if (sql.includes('EXISTS')) {
+      // Try to extract table and conditions for better TODO comment
+      const tableMatch = sql.match(/FROM\s+(\w+)/i);
+      const table = tableMatch ? tableMatch[1] : 'related_table';
+      return `true /* TODO: Check ${table} relationship */`;
+    }
+
+    // Handle boolean literals
+    if (sql.toLowerCase() === 'true') return 'true';
+    if (sql.toLowerCase() === 'false') return 'false';
+
+    return `true /* Unhandled: ${sql.substring(0, 50)}... */`;
+  }
+
+  /**
+   * Get JavaScript mapping for a PostgreSQL function
+   */
+  function getFunctionMapping(funcName, userVar) {
+    // Check analyzed mappings first
+    if (functionMappings[funcName]) {
+      const mapping = functionMappings[funcName];
+      if (mapping.javascript) {
+        // Replace 'user' placeholder with actual variable name
+        return mapping.javascript.replace(/user/g, userVar);
+      }
+    }
+
+    // Special case for role functions - they should map to user?.role not user?.user_role
+    if (funcName.toLowerCase() === 'get_current_user_role' ||
+        funcName.toLowerCase() === 'current_user_role') {
+      return `${userVar}?.role`;
+    }
+
+    // Fallback: infer from function name
+    // get_current_X -> user?.X
+    const getCurrentMatch = funcName.match(/get_current_(\w+)/i);
+    if (getCurrentMatch) {
+      return `${userVar}?.${getCurrentMatch[1]}`;
+    }
+
+    // current_X -> user?.X
+    const currentMatch = funcName.match(/current_(\w+)/i);
+    if (currentMatch) {
+      return `${userVar}?.${currentMatch[1]}`;
+    }
+
+    // Unknown function
+    return `${userVar}?.${funcName}()`;
+  }
+
+  /**
+   * Get JavaScript mapping for a session variable
+   */
+  function getSessionMapping(setting, userVar) {
+    // Check analyzed mappings
+    if (sessionVariables[setting]) {
+      return sessionVariables[setting].replace(/user/g, userVar);
+    }
+
+    // Fallback: infer from setting name
+    if (setting.includes('user_id')) {
+      return `${userVar}?.id`;
+    }
+
+    const parts = setting.split('.');
+    const lastPart = parts[parts.length - 1];
+    return `${userVar}?.${lastPart}`;
+  }
+
+  /**
+   * Convert CASE WHEN
+   */
+  function convertCaseWhen(sql, dataVar, userVar) {
+    const caseMatch = sql.match(/CASE\s+([^W]+)\s+((?:WHEN[\s\S]+?)+)(?:\s+ELSE\s+([\s\S]+?))?\s*END/i);
+    if (!caseMatch) return 'false';
+
+    const caseExpr = caseMatch[1].trim();
+    const whenClauses = caseMatch[2];
+    const elseClause = caseMatch[3];
+
+    // Extract function name from CASE expression
+    const funcMatch = caseExpr.match(/(\w+)\s*\(/);
+    const testExpression = funcMatch ? getFunctionMapping(funcMatch[1], userVar) : caseExpr;
+
+    const conditions = [];
+    const whenPattern = /WHEN\s+'?([^':\s]+)'?(?:::\w+)?\s+THEN\s+((?:(?!WHEN|ELSE|END).)+)/gi;
+
+    let match;
+    while ((match = whenPattern.exec(whenClauses)) !== null) {
+      const value = match[1];
+      const thenExpr = match[2].trim();
+
+      if (thenExpr.toLowerCase() === 'true') {
+        conditions.push(`${testExpression} === '${value}'`);
+      } else if (thenExpr.toLowerCase() !== 'false') {
+        const thenJs = convertToJavaScript(thenExpr, dataVar, userVar);
+        conditions.push(`(${testExpression} === '${value}' && ${thenJs})`);
+      }
+    }
+
+    if (elseClause && elseClause.trim().toLowerCase() !== 'false') {
+      conditions.push(convertToJavaScript(elseClause.trim(), dataVar, userVar));
+    }
+
+    return conditions.length > 0 ? `(${conditions.join(' || ')})` : 'false';
+  }
+
+  /**
+   * Convert to Prisma filter
+   */
+  function convertToPrismaFilter(sql, userVar = 'user') {
+    if (!sql || sql.trim() === '') return '{}';
+
+    sql = sql.trim().replace(/\s+/g, ' ').replace(/\n/g, ' ');
+
+    // Handle OR conditions
+    const orParts = splitLogicalOperator(sql, 'OR');
+    if (orParts.length > 1) {
+      const orFilters = orParts
+        .map(part => convertToPrismaFilter(part, userVar))
+        .filter(f => f !== '{}');
+
+      if (orFilters.length === 0) return '{}';
+      if (orFilters.length === 1) return orFilters[0];
+      return `{ OR: [${orFilters.join(', ')}] }`;
+    }
+
+    // Handle AND conditions
+    const andParts = splitLogicalOperator(sql, 'AND');
+    if (andParts.length > 1) {
+      const andFilters = andParts
+        .map(part => convertToPrismaFilter(part, userVar))
+        .filter(f => f !== '{}');
+
+      if (andFilters.length === 0) return '{}';
+      if (andFilters.length === 1) return andFilters[0];
+      return `{ AND: [${andFilters.join(', ')}] }`;
+    }
+
+    // Skip role-only checks (they can't be filtered in Prisma)
+    if (sql.match(/^\s*(?:get_current_user_role|current_user_role)\s*\(\)/i)) {
+      return '{}';
+    }
+
+    // Extract field comparisons
+    const filters = [];
+
+    // Handle: field = function()
+    const fieldFuncMatch = sql.match(/^(\w+)\s*=\s*(\w+)\s*\([^)]*\)$/i);
+    if (fieldFuncMatch) {
+      const field = fieldFuncMatch[1];
+      const funcName = fieldFuncMatch[2];
+
+      // Skip role functions
+      if (funcName.toLowerCase().includes('role')) {
+        return '{}';
+      }
+
+      const jsExpression = getFunctionMapping(funcName, userVar);
+      return `{ ${field}: ${jsExpression} }`;
+    }
+
+    // Handle: field = (current_setting('...'))
+    const settingMatch = sql.match(/^(\w+)\s*=\s*\(\s*current_setting\s*\(\s*'([^']+)'/i);
+    if (settingMatch) {
+      const field = settingMatch[1];
+      const setting = settingMatch[2];
+      const jsExpression = getSessionMapping(setting, userVar);
+      return `{ ${field}: ${jsExpression} }`;
+    }
+
+    // Handle: field = 'value' (direct comparison)
+    const directMatch = sql.match(/^(\w+)\s*=\s*'([^']+)'/i);
+    if (directMatch) {
+      const field = directMatch[1];
+      const value = directMatch[2];
+      return `{ ${field}: '${value}' }`;
+    }
+
+    // Handle: field = number
+    const numberMatch = sql.match(/^(\w+)\s*=\s*(\d+)$/i);
+    if (numberMatch) {
+      const field = numberMatch[1];
+      const value = numberMatch[2];
+      return `{ ${field}: ${value} }`;
+    }
+
+    // Can't convert complex conditions to Prisma filters
+    return '{}';
+  }
+
+  return { convertToJavaScript, convertToPrismaFilter };
+}
+
+/**
+ * Helper: Split by logical operator respecting parentheses
+ */
+function splitLogicalOperator(sql, operator) {
+  const parts = [];
+  let current = '';
+  let depth = 0;
+  let inQuotes = false;
+  let i = 0;
+
+  while (i < sql.length) {
+    if (sql[i] === "'" && !inQuotes) {
+      inQuotes = true;
+    } else if (sql[i] === "'" && inQuotes) {
+      inQuotes = false;
+    } else if (!inQuotes) {
+      if (sql[i] === '(') depth++;
+      else if (sql[i] === ')') depth--;
+      else if (depth === 0) {
+        const upcoming = sql.substring(i, i + operator.length + 2);
+        if (upcoming.match(new RegExp(`\\s+${operator}\\s+`, 'i'))) {
+          if (current.trim()) parts.push(current.trim());
+          current = '';
+          i += upcoming.match(/\s+\w+\s+/)[0].length - 1;
+        }
+      }
+    }
+    current += sql[i];
+    i++;
+  }
+
+  if (current.trim()) parts.push(current.trim());
+  return parts.length > 1 ? parts : [sql];
+}
+
+/**
+ * Helper: Extract array values
+ */
+function extractArrayValues(arrayContent) {
+  return arrayContent
+    .split(',')
+    .map(r => r.trim())
+    .map(r => r.replace(/::[^,\]]+/g, ''))
+    .map(r => r.replace(/^'|'$/g, ''))
+    .map(r => `'${r}'`)
+    .join(', ');
+}
+
+module.exports = { createConverter };

package/src/parsers/datasourceParser.js

@@ -0,0 +1,73 @@
+const fs = require('fs');
+const path = require('path');
+
+// Load .env file if it exists
+try {
+  require('dotenv').config({ path: path.join(process.cwd(), '.env') });
+} catch (e) {
+  // dotenv not available, skip
+}
+
+/**
+ * Parse datasource configuration from Prisma schema
+ * @param {string} schemaPath - Path to Prisma schema file
+ * @returns {Object} - Datasource configuration with resolved URL
+ */
+function parseDatasource(schemaPath) {
+  const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+
+  // Extract datasource block
+  const datasourceRegex = /datasource\s+\w+\s*{([^}]*)}/;
+  const match = schemaContent.match(datasourceRegex);
+
+  if (!match) {
+    throw new Error('No datasource block found in Prisma schema');
+  }
+
+  const datasourceBlock = match[1];
+
+  // Extract provider
+  const providerMatch = datasourceBlock.match(/provider\s*=\s*"([^"]+)"/);
+  const provider = providerMatch ? providerMatch[1] : null;
+
+  // Extract url
+  const urlMatch = datasourceBlock.match(/url\s*=\s*(.+)/);
+  if (!urlMatch) {
+    throw new Error('No url found in datasource block');
+  }
+
+  let url = urlMatch[1].trim();
+
+  // Handle env() function
+  const envMatch = url.match(/env\(["']([^"']+)["']\)/);
+  if (envMatch) {
+    const envVar = envMatch[1];
+    url = process.env[envVar];
+
+    if (!url) {
+      throw new Error(`Environment variable ${envVar} is not defined`);
+    }
+  } else {
+    // Remove quotes if present
+    url = url.replace(/^["']|["']$/g, '');
+  }
+
+  // Detect PostgreSQL from provider OR from the actual connection URL
+  // This is important because the schema might say "mysql" but DATABASE_URL could be postgresql://
+  let isPostgreSQL = provider === 'postgresql' || provider === 'postgres';
+
+  if (!isPostgreSQL && url) {
+    // Check if URL starts with postgresql:// or postgres://
+    isPostgreSQL = url.startsWith('postgresql://') || url.startsWith('postgres://');
+  }
+
+  return {
+    provider,
+    url,
+    isPostgreSQL
+  };
+}
+
+module.exports = {
+  parseDatasource
+};