Remove old generateTsAstCodeFromPgAst and rename schema-based function

- Remove implementation of generateTsAstCodeFromPgAst (old function without schema)
- Rename generateTsAstCodeFromPgAstWithSchema to generateTsAstCodeFromPgAst
- Update all test imports and function calls to use renamed function
- Update README documentation to reflect schema requirement
- All tests passing with updated snapshots

The function now always uses runtime schema for proper node wrapping decisions.

Co-Authored-By: Dan Lynch <[email protected]>

Author: devin-ai-integration[bot]

packages/proto-parser/README.md

@@ -253,23 +253,25 @@ Each of these options can be set when initializing the `PgProtoParser` to custom
 
 `generateTsAstCodeFromPgAst` is a method that transforms a PostgreSQL Abstract Syntax Tree (AST) into TypeScript code capable of generating an equivalent AST. This function facilitates the dynamic creation of ASTs, allowing for programmable query construction and manipulation in TypeScript.
 
-It generates code with syntax for [@pgsql/utils](https://github.com/launchql/pgsql-parser/tree/main/packages/utils), assuming you import the `ast` as as default import from `@pgsql/utils`:
+It generates code with syntax for [@pgsql/utils](https://github.com/launchql/pgsql-parser/tree/main/packages/utils), using runtime schema information to determine whether nodes should be wrapped (`t.nodes.*`) or unwrapped (`t.ast.*`).
 
 ```ts
 import { 
   generateTsAstCodeFromPgAst
 } from 'pg-proto-parser';
 import { parse } from 'pgsql-parser';
+import { runtimeSchema } from 'pg-proto-parser/runtime-schema';
 
 // Example SQL query
 const sql = 'SELECT * FROM my_table WHERE id = 1';
 
 // Parse the SQL query to get the PostgreSQL AST
 const pgAst = parse(sql);
 
-// Generate TypeScript AST builder code from the PostgreSQL AST
+// Generate TypeScript AST builder code from the PostgreSQL AST using runtime schema
 const tsAstBuilderCode = generateTsAstCodeFromPgAst(
-  pgAst[0].RawStmt.stmt
+  pgAst[0].RawStmt.stmt,
+  runtimeSchema
 );
 
 console.log(tsAstBuilderCode);
@@ -330,4 +332,4 @@ ast.selectStmt({
 
 AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
 
-No developer or entity involved in creating Software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the Software code or Software CLI, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.
+No developer or entity involved in creating Software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the Software code or Software CLI, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.

packages/proto-parser/__tests__/meta.test.ts

@@ -1,6 +1,6 @@
 import * as t from '../test-utils/meta';
 import { SelectStmt } from '@pgsql/types';
-import { generateTsAstCodeFromPgAst, generateTsAstCodeFromPgAstWithSchema } from '../src/utils'
+import { generateTsAstCodeFromPgAst } from '../src/utils'
 import { runtimeSchema } from '../test-utils/meta/runtime-schema';
 import generate from '@babel/generator';
 
@@ -24,7 +24,7 @@ it('AST to AST to create AST — meta 🤯', () => {
         op: 'SETOP_NONE'
       });
 
-      const astForAst = generateTsAstCodeFromPgAst(selectStmt);
+      const astForAst = generateTsAstCodeFromPgAst(selectStmt, runtimeSchema);
       expect(generate(astForAst).code).toMatchSnapshot();
 });
 
@@ -366,7 +366,7 @@ it('Complex AST — Advanced SQL with CTEs, Window Functions, Joins, and Subquer
       op: 'SETOP_NONE'
     });
 
-    const astForComplexAst = generateTsAstCodeFromPgAstWithSchema(complexSelectStmt, runtimeSchema);
+    const astForComplexAst = generateTsAstCodeFromPgAst(complexSelectStmt, runtimeSchema);
     expect(generate(astForComplexAst).code).toMatchSnapshot();
 });
 
@@ -390,7 +390,7 @@ it('Enhanced AST generation with runtime schema — wrapped vs unwrapped nodes',
         op: 'SETOP_NONE'
     });
 
-    const enhancedAst = generateTsAstCodeFromPgAstWithSchema(selectStmt, runtimeSchema);
+    const enhancedAst = generateTsAstCodeFromPgAst(selectStmt, runtimeSchema);
     const generatedCode = generate(enhancedAst).code;
 
     expect(generatedCode).toMatchSnapshot();
@@ -430,7 +430,7 @@ it('Complex AST with runtime schema — mixed wrapped/unwrapped patterns', () =>
         op: 'SETOP_NONE'
     });
 
-    const enhancedAst = generateTsAstCodeFromPgAstWithSchema(complexStmt, runtimeSchema);
+    const enhancedAst = generateTsAstCodeFromPgAst(complexStmt, runtimeSchema);
     const generatedCode = generate(enhancedAst).code;
 
     expect(generatedCode).toMatchSnapshot();

packages/proto-parser/src/utils/meta.ts

@@ -13,52 +13,9 @@ import { NodeSpec, FieldSpec } from '../runtime-schema/types';
 
 // TODO — handle TypeName and SPECIAL_TYPES cases
 
-export function generateTsAstCodeFromPgAst(ast: any): any {
-    function createAstNode(functionName: string, properties: any) {
-      const args = properties.map(([propKey, propValue]: [string, any]) => {
-        return t.objectProperty(t.identifier(propKey), getValueNode(propValue));
-      });
-      return t.callExpression(
-        t.memberExpression(t.identifier('ast'), t.identifier(functionName)),
-        [t.objectExpression(args)]
-      );
-    }
-  
-    function getValueNode(value: any): t.Expression {
-      if (typeof value === 'object') {
-        return value === null ? t.nullLiteral() : traverse(value);
-      }
-      switch (typeof value) {
-        case 'boolean':
-          return t.booleanLiteral(value);
-        case 'number':
-          return t.numericLiteral(value);
-        case 'string':
-          return t.stringLiteral(value);
-        default:
-          return t.stringLiteral(String(value)); // Fallback for other types
-      }
-    }
-  
-    function traverse(node: any): t.Expression {
-      if (Array.isArray(node)) {
-        return t.arrayExpression(node.map(traverse));
-      } else if (node && typeof node === 'object') {
-        const entries = Object.entries(node);
-        if (entries.length === 0) return t.objectExpression([]);
-  
-        const [key, value] = entries[0]; // Processing one key-value pair per object
-        const functionName = toSpecialCamelCase(key);
-        return createAstNode(functionName, Object.entries(value));
-      }
-  
-      return getValueNode(node);
-    }
-  
-    return traverse(ast);
-  }
 
-export function generateTsAstCodeFromPgAstWithSchema(ast: any, runtimeSchema: NodeSpec[]): any {
+
+export function generateTsAstCodeFromPgAst(ast: any, runtimeSchema: NodeSpec[]): any {
     const schemaMap = new Map<string, NodeSpec>();
     runtimeSchema.forEach(spec => {
         schemaMap.set(spec.name, spec);