refactor(codegen): replace pgTypesFile with metaFile / --dump-meta approach

- Expand MetaTableInfo to include fields[] with type.pgType from _meta
- Replace enrichPgTypes(PgTypesMap) with enrichPgTypesFromMeta(MetaTableInfo[])
- Rename pgTypesFile -> metaFile in config (full _meta dump, not pgType-specific)
- Rename --dump-pg-types -> --dump-meta in CLI (dumps MetaTableInfo[])
- Pipeline now auto-enriches pgType from _meta in database mode
- metaFile serves as sidecar for file/schemaDir/endpoint modes
- Heuristic fallbacks still work when no _meta is available
- Update all tests to match new API (19 tests passing)

Author: pyramation

graphql/codegen/src/__tests__/introspect/dump-pg-types.test.ts

@@ -1,4 +1,4 @@
-import { buildPgTypesMap } from '../../core/dump-pg-types';
+import { buildMetaFromTables } from '../../core/dump-pg-types';
 import type { Table } from '../../types/schema';
 
 function makeField(name: string, gqlType: string, isArray = false, pgType?: string | null) {
@@ -20,8 +20,8 @@ function makeTable(name: string, fields: ReturnType<typeof makeField>[]): Table
   };
 }
 
-describe('buildPgTypesMap', () => {
-  it('should build map from tables with pgType', () => {
+describe('buildMetaFromTables', () => {
+  it('should build MetaTableInfo[] from tables with pgType', () => {
     const tables = [
       makeTable('Document', [
         makeField('id', 'UUID', false, 'uuid'),
@@ -30,67 +30,71 @@ describe('buildPgTypesMap', () => {
       ]),
     ];
 
-    const result = buildPgTypesMap(tables);
-    expect(result).toEqual({
-      Document: {
-        id: { pgType: 'uuid' },
-        vectorEmbedding: { pgType: 'vector' },
-        tsvContent: { pgType: 'tsvector' },
-      },
-    });
+    const result = buildMetaFromTables(tables);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('Document');
+    expect(result[0].fields).toEqual([
+      { name: 'id', type: { pgType: 'uuid', gqlType: 'UUID', isArray: false } },
+      { name: 'vectorEmbedding', type: { pgType: 'vector', gqlType: 'Float', isArray: true } },
+      { name: 'tsvContent', type: { pgType: 'tsvector', gqlType: 'FullText', isArray: false } },
+    ]);
   });
 
-  it('should set pgType to null when not available (template mode)', () => {
+  it('should set pgType to "unknown" when not available', () => {
     const tables = [
       makeTable('User', [
         makeField('id', 'UUID'),
         makeField('name', 'String'),
       ]),
     ];
 
-    const result = buildPgTypesMap(tables);
-    expect(result).toEqual({
-      User: {
-        id: { pgType: null },
-        name: { pgType: null },
-      },
-    });
+    const result = buildMetaFromTables(tables);
+    expect(result).toHaveLength(1);
+    expect(result[0].fields).toEqual([
+      { name: 'id', type: { pgType: 'unknown', gqlType: 'UUID', isArray: false } },
+      { name: 'name', type: { pgType: 'unknown', gqlType: 'String', isArray: false } },
+    ]);
   });
 
-  it('should include pgAlias and typmod when present', () => {
+  it('should preserve relations', () => {
     const tables: Table[] = [
       {
         name: 'Article',
         fields: [
-          {
-            name: 'embedding',
-            type: {
-              gqlType: 'Float',
-              isArray: true,
-              pgType: 'vector',
-              pgAlias: 'vector',
-              typmod: 768,
-            },
-          },
+          { name: 'id', type: { gqlType: 'UUID', isArray: false, pgType: 'uuid' } },
         ],
-        relations: { belongsTo: [], hasOne: [], hasMany: [], manyToMany: [] },
+        relations: {
+          belongsTo: [],
+          hasOne: [],
+          hasMany: [],
+          manyToMany: [{
+            fieldName: 'tags',
+            rightTable: 'Tag',
+            junctionTable: 'ArticleTag',
+            type: 'Tag',
+            junctionLeftKeyFields: ['articleId'],
+            junctionRightKeyFields: ['tagId'],
+            leftKeyFields: ['id'],
+            rightKeyFields: ['id'],
+          }],
+        },
       },
     ];
 
-    const result = buildPgTypesMap(tables);
-    expect(result.Article.embedding).toEqual({
-      pgType: 'vector',
-      pgAlias: 'vector',
-      typmod: 768,
-    });
+    const result = buildMetaFromTables(tables);
+    expect(result[0].relations.manyToMany).toHaveLength(1);
+    expect(result[0].relations.manyToMany[0].junctionTable.name).toBe('ArticleTag');
+    expect(result[0].relations.manyToMany[0].rightTable.name).toBe('Tag');
   });
 
   it('should handle empty tables array', () => {
-    expect(buildPgTypesMap([])).toEqual({});
+    expect(buildMetaFromTables([])).toEqual([]);
   });
 
   it('should handle tables with no fields', () => {
     const tables = [makeTable('Empty', [])];
-    expect(buildPgTypesMap(tables)).toEqual({});
+    const result = buildMetaFromTables(tables);
+    expect(result).toHaveLength(1);
+    expect(result[0].fields).toEqual([]);
   });
 });