Merge branch 'devin/1750812347-fix-pg13-pg14-transformer' of https://git-manager.devin.ai/proxy/github.com/launchql/pgsql-parser into devin/1750812347-fix-pg13-pg14-transformer

Author: devin-ai-integration[bot]

packages/transform/test-utils/clean-tree.ts

@@ -38,7 +38,11 @@ export const cleanLines = (sql: string) => {
         if (obj.hasOwnProperty(attr)) {
           if (props.hasOwnProperty(attr)) {
             if (typeof props[attr] === 'function') {
-              copy[attr] = props[attr](obj[attr]);
+              const transformedValue = props[attr](obj[attr]);
+              // Only add the property if the transformer doesn't return undefined
+              if (transformedValue !== undefined) {
+                copy[attr] = transformedValue;
+              }
             } else if (props[attr].hasOwnProperty(obj[attr])) {
               copy[attr] = props[attr][obj[attr]];
             } else {

packages/transform/test-utils/index.ts

@@ -3,7 +3,7 @@ import { cleanTree } from './clean-tree';
 import { readFileSync } from 'fs';
 import * as path from 'path';
 import { expect } from '@jest/globals';
-
+import { diff } from 'jest-diff';
 const parser13 = new Parser(13 as any);
 const parser14 = new Parser(14 as any);
 const parser15 = new Parser(15 as any);
@@ -55,53 +55,6 @@ export function getTransformerForVersion(versionPrevious: number, versionNext: n
   return new ASTTransformer();
 }
 
-/**
- * Helper function to find the first difference between two objects
- */
-function findFirstDifference(obj1: any, obj2: any, path: string = ''): { path: string; expected: any; actual: any } | null {
-  // Handle primitive values
-  if (obj1 === obj2) return null;
-  if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null) {
-    return { path, expected: obj1, actual: obj2 };
-  }
-  
-  // Handle arrays
-  if (Array.isArray(obj1) && Array.isArray(obj2)) {
-    if (obj1.length !== obj2.length) {
-      return { path: `${path}.length`, expected: obj1.length, actual: obj2.length };
-    }
-    for (let i = 0; i < obj1.length; i++) {
-      const diff = findFirstDifference(obj1[i], obj2[i], `${path}[${i}]`);
-      if (diff) return diff;
-    }
-    return null;
-  }
-  
-  // Handle objects
-  const keys1 = Object.keys(obj1).sort();
-  const keys2 = Object.keys(obj2).sort();
-  
-  // Check for missing/extra keys
-  if (keys1.length !== keys2.length || keys1.some((k, i) => k !== keys2[i])) {
-    const missingInObj2 = keys1.filter(k => !keys2.includes(k));
-    const extraInObj2 = keys2.filter(k => !keys1.includes(k));
-    if (missingInObj2.length > 0) {
-      return { path: `${path}.${missingInObj2[0]}`, expected: obj1[missingInObj2[0]], actual: undefined };
-    }
-    if (extraInObj2.length > 0) {
-      return { path: `${path}.${extraInObj2[0]}`, expected: undefined, actual: obj2[extraInObj2[0]] };
-    }
-  }
-  
-  // Check values
-  for (const key of keys1) {
-    const diff = findFirstDifference(obj1[key], obj2[key], path ? `${path}.${key}` : key);
-    if (diff) return diff;
-  }
-  
-  return null;
-}
-
 /**
  * Perform the parse-transform-parse equality test
  */
@@ -111,7 +64,8 @@ export async function expectTransformedAstToEqualParsedAst(
   parserNext: any,
   transformer: ASTTransformer,
   versionPrevious: number,
-  versionNext: number
+  versionNext: number,
+  relativePath?: string
 ): Promise<void> {
   const parsedPrevious = await parserPrevious.parse(sql);
   const parsedNext = await parserNext.parse(sql);
@@ -129,13 +83,13 @@ export async function expectTransformedAstToEqualParsedAst(
           return { ...stmtWrapper, stmt: transformedStmt };
         } catch (error: any) {
           const errorMessage = [
-            `\n❌ TRANSFORMATION ERROR`,
-            `   Previous Version: ${versionPrevious}`,
-            `   Next Version: ${versionNext}`,
-            `   Statement Index: ${index}`,
-            `   Statement Type: ${Object.keys(stmtWrapper.stmt)[0]}`,
-            `   Error: ${error.message}`,
-            `\n   Original Statement:`,
+            `\n❌ TRANSFORMATION ERROR ${relativePath ? `(${relativePath})` : ''}`,
+            `   ⚠️ Previous Version: ${versionPrevious}`,
+            `   ⚠️ Next Version: ${versionNext}`,
+            `   ⚠️ Statement Index: ${index}`,
+            `   ⚠️ Statement Type: ${Object.keys(stmtWrapper.stmt)[0]}`,
+            `   ⚠️ Error: ${error.message}`,
+            `\n   ⚠️ Original Statement:`,
             JSON.stringify(stmtWrapper.stmt, null, 2)
           ].join('\n');
 
@@ -161,22 +115,19 @@ export async function expectTransformedAstToEqualParsedAst(
     expect(nextAst).toEqual(previousTransformedAst);
   } catch (error: any) {
     // Try to find the first difference
-    const diff = findFirstDifference(nextAst, previousTransformedAst);
+    const d = diff(nextAst, previousTransformedAst);
 
     const errorMessage = [
-      `\n❌ TRANSFORMATION MISMATCH`,
-      `   Previous Version: ${versionPrevious}`,
-      `   Next Version: ${versionNext}`,
-      `   SQL: ${sql}`,
-      `\n   Expected (parsed with v${versionNext}):`,
+      `\n❌ TRANSFORMATION MISMATCH ${relativePath ? `(${relativePath})` : ''}`,
+      `   ⚠️ Previous Version: ${versionPrevious}`,
+      `   ⚠️ Next Version: ${versionNext}`,
+      `   ⚠️ SQL: ${sql}`,
+      `\n   ⚠️ Expected (parsed with v${versionNext}):`,
       JSON.stringify(nextAst, null, 2),
-      `\n   Actual (transformed from v${versionPrevious}):`,
-      JSON.stringify(previousTransformedAst, null, 2),
-      diff ? `\n   First difference at path: ${diff.path}` : '',
-      diff ? `   Expected: ${JSON.stringify(diff.expected)}` : '',
-      diff ? `   Actual: ${JSON.stringify(diff.actual)}` : ''
+      `\n   ⚠️ Actual (transformed from v${versionPrevious}):`,
+      JSON.stringify(previousTransformedAst, null, 2)
     ].filter(line => line !== '').join('\n');
-    
+    console.log(relativePath + ':\n' + d);
     console.error(errorMessage);
     throw error;
   }
@@ -229,7 +180,7 @@ export class FixtureTestUtils {
 
   async expectParseTransformParseToBeEqual(relativePath: string, sql: string) {
     // Use the modular helper function instead of duplicating logic
-    await expectTransformedAstToEqualParsedAst(sql, this.parserPrevious, this.parserNext, this.transformer, this.versionPrevious, this.versionNext);
+    await expectTransformedAstToEqualParsedAst(sql, this.parserPrevious, this.parserNext, this.transformer, this.versionPrevious, this.versionNext, relativePath);
   }
 
   async runFixtureTests(filters: string[]) {