attempt at meta

Author: pyramation

packages/proto-parser/__tests__/__snapshots__/meta-with-schema.test.ts.snap

@@ -0,0 +1,75 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`AST to AST with runtime schema should generate t.ast.* for wrapped nodes and t.nodes.* for non-wrapped nodes 1`] = `
+"t.ast.selectStmt({
+  targetList: [t.ast.resTarget({
+    val: t.ast.columnRef({
+      fields: [t.ast.aStar({})]
+    })
+  })],
+  fromClause: [t.ast.rangeVar({
+    relname: "users_table",
+    inh: true,
+    relpersistence: "p"
+  })],
+  limitOption: "LIMIT_OPTION_DEFAULT",
+  op: "SETOP_NONE"
+})"
+`;
+
+exports[`AST to AST with runtime schema should handle arrays of nodes 1`] = `
+"t.ast.list({
+  items: [t.ast.string({
+    sval: "first"
+  }), t.ast.string({
+    sval: "second"
+  }), t.ast.string({
+    sval: "third"
+  })]
+})"
+`;
+
+exports[`AST to AST with runtime schema should handle empty objects and null values 1`] = `
+"t.ast.resTarget({
+  name: null,
+  val: t.ast.columnRef({
+    fields: [t.ast.aStar({})]
+  })
+})"
+`;
+
+exports[`AST to AST with runtime schema should handle mixed wrapped and non-wrapped nodes 1`] = `
+"t.ast.aExpr({
+  kind: "AEXPR_OP",
+  name: [t.ast.string({
+    sval: "="
+  })],
+  lexpr: t.ast.columnRef({
+    fields: [t.ast.string({
+      sval: "id"
+    })]
+  }),
+  rexpr: t.ast.aConst({
+    ival: t.nodes.aConst({
+      ival: 42
+    })
+  })
+})"
+`;
+
+exports[`AST to AST with runtime schema should use t.nodes.* for non-wrapped nodes 1`] = `
+"t.nodes.parseResult({
+  version: 160001,
+  stmts: [t.ast.rawStmt({
+    stmt: t.nodes.selectStmt({
+      targetList: [t.nodes.resTarget({
+        val: t.nodes.columnRef({
+          fields: [t.nodes.aStar({})]
+        })
+      })],
+      limitOption: "LIMIT_OPTION_DEFAULT",
+      op: "SETOP_NONE"
+    })
+  })]
+})"
+`;

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

@@ -0,0 +1,112 @@
+import * as t from '../test-utils/meta';
+import { A_Expr, List, ParseResult, ResTarget, SelectStmt } from '@pgsql/types';
+import { generateTsAstCodeFromPgAstWithSchema } from '../src/utils';
+import generate from '@babel/generator';
+import { runtimeSchema } from '../test-utils/meta/runtime-schema';
+
+describe('AST to AST with runtime schema', () => {
+  it('should generate t.ast.* for wrapped nodes and t.nodes.* for non-wrapped nodes', () => {
+    // Create a simple AST using the wrapped helpers
+    const selectStmt: { SelectStmt: SelectStmt } = t.nodes.selectStmt({
+      targetList: [
+        t.nodes.resTarget({
+          val: t.nodes.columnRef({
+            fields: [t.nodes.aStar()]
+          })
+        })
+      ],
+      fromClause: [
+        t.nodes.rangeVar({
+          relname: 'users_table',
+          inh: true,
+          relpersistence: 'p'
+        })
+      ],
+      limitOption: 'LIMIT_OPTION_DEFAULT',
+      op: 'SETOP_NONE'
+    });
+
+    // Generate code using the new function with runtime schema
+    const astForAst = generateTsAstCodeFromPgAstWithSchema(selectStmt, runtimeSchema);
+    const generatedCode = generate(astForAst).code;
+    expect(generatedCode).toMatchSnapshot();
+  });
+
+  it('should handle mixed wrapped and non-wrapped nodes', () => {
+    // Create an AST with both wrapped and non-wrapped nodes
+    const testAst: { A_Expr: A_Expr } = t.nodes.aExpr({
+      kind: 'AEXPR_OP',
+      name: [t.nodes.string({ sval: '=' })],
+      lexpr: t.nodes.columnRef({
+        fields: [t.nodes.string({ sval: 'id' })]
+      }),
+      rexpr: t.nodes.aConst({
+        ival: t.ast.integer({ ival: 42 })
+      })
+    });
+
+    const astForAst = generateTsAstCodeFromPgAstWithSchema(testAst, runtimeSchema);
+    const generatedCode = generate(astForAst).code;
+    expect(generatedCode).toMatchSnapshot();
+  });
+
+  it('should handle arrays of nodes', () => {
+    const testAst: { List: List } = t.nodes.list({
+      items: [
+        t.nodes.string({ sval: 'first' }),
+        t.nodes.string({ sval: 'second' }),
+        t.nodes.string({ sval: 'third' })
+      ]
+    });
+
+    const astForAst = generateTsAstCodeFromPgAstWithSchema(testAst, runtimeSchema);
+    const generatedCode = generate(astForAst).code;
+    expect(generatedCode).toMatchSnapshot();
+  });
+
+  it('should handle empty objects and null values', () => {
+    const testAst: { ResTarget: ResTarget } = t.nodes.resTarget({
+      name: null,
+      val: t.nodes.columnRef({
+        fields: [t.nodes.aStar()]
+      })
+    });
+
+    const astForAst = generateTsAstCodeFromPgAstWithSchema(testAst, runtimeSchema);
+    const generatedCode = generate(astForAst).code;
+    expect(generatedCode).toMatchSnapshot();
+  });
+
+  it('should use t.nodes.* for non-wrapped nodes', () => {
+    // Test that unwrapped nodes (plain objects) are converted to t.nodes.* calls
+    const testAst: { ParseResult: ParseResult } = t.nodes.parseResult({
+      version: 160001,
+      stmts: [
+        t.ast.rawStmt({
+          stmt: {
+            // This is an unwrapped SelectStmt - just a plain object with SelectStmt fields
+            targetList: [
+              {
+                ResTarget: {
+                  val: {
+                    ColumnRef: {
+                      fields: [
+                        { A_Star: {} }
+                      ]
+                    }
+                  }
+                }
+              }
+            ],
+            limitOption: 'LIMIT_OPTION_DEFAULT',
+            op: 'SETOP_NONE'
+          }
+        })
+      ]
+    });
+
+    const astForAst = generateTsAstCodeFromPgAstWithSchema(testAst, runtimeSchema);
+    const generatedCode = generate(astForAst).code;
+    expect(generatedCode).toMatchSnapshot();
+  });
+});

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

@@ -1,18 +1,18 @@
-import ast from '../test-utils/utils/asts';
+import wrapped from '../test-utils/meta/wrapped';
 import { generateTsAstCodeFromPgAst } from '../src/utils'
 import generate from '@babel/generator';
 
 it('AST to AST to create AST — meta 🤯', () => {
-    const selectStmt = ast.selectStmt({
+    const selectStmt = wrapped.selectStmt({
         targetList: [
-          ast.resTarget({
-            val: ast.columnRef({
-              fields: [ast.aStar()]
+          wrapped.resTarget({
+            val: wrapped.columnRef({
+              fields: [wrapped.aStar()]
             })
           })
         ],
         fromClause: [
-          ast.rangeVar({
+          wrapped.rangeVar({
             relname: 'some_amazing_table',
             inh: true,
             relpersistence: 'p'