@dbml/connector 10.4.0-alpha.1 → 10.4.0-metadata-ref-type.0

package/__tests__/connector.test.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { Client } from 'pg';
 import { scanDirNames } from './testHelpers';
 import { connector } from '../src/index';
 
@@ -44,4 +45,76 @@ describe('@dbml/connector', () => {
   test.each(scanDirNames(__dirname, 'connectors'))('connectors/%s', async (dirName) => {
     await runTest(path.join(__dirname, 'connectors', dirName));
   }, 10000);
+
+  test('postgres preserves composite foreign key column order', async () => {
+    const testDir = path.join(__dirname, 'connectors', 'postgres');
+    const { connection } = JSON.parse(fs.readFileSync(path.join(testDir, 'connection.json'), 'utf-8'));
+    const schema = `dbml_fk_order_${Math.random().toString(16).slice(2)}`;
+    const client = new Client({ connectionString: connection });
+
+    await client.connect();
+    try {
+      await client.query(`CREATE SCHEMA "${schema}"`);
+      await client.query(`
+        CREATE TABLE "${schema}".parent (
+          zeta integer NOT NULL,
+          alpha integer NOT NULL,
+          PRIMARY KEY (zeta, alpha)
+        );
+        CREATE TABLE "${schema}".child (
+          id integer PRIMARY KEY,
+          a_zeta integer,
+          z_alpha integer,
+          CONSTRAINT child_parent_fk FOREIGN KEY (a_zeta, z_alpha)
+            REFERENCES "${schema}".parent (zeta, alpha)
+        );
+      `);
+
+      const schemaJson = await connector.fetchSchemaJson(`${connection}?schemas=${schema}`, 'postgres');
+      const ref = schemaJson.refs.find(({ name }) => name === 'child_parent_fk');
+
+      expect(ref?.endpoints[0].fieldNames).toEqual(['a_zeta', 'z_alpha']);
+      expect(ref?.endpoints[1].fieldNames).toEqual(['zeta', 'alpha']);
+    } finally {
+      await client.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+      await client.end();
+    }
+  });
+
+  test('postgres keeps array column defaults that are not an ARRAY[...] list', async () => {
+    const testDir = path.join(__dirname, 'connectors', 'postgres');
+    const { connection } = JSON.parse(fs.readFileSync(path.join(testDir, 'connection.json'), 'utf-8'));
+    const schema = `dbml_array_default_${Math.random().toString(16).slice(2)}`;
+    const client = new Client({ connectionString: connection });
+
+    await client.connect();
+    try {
+      await client.query(`CREATE SCHEMA "${schema}"`);
+      await client.query(`
+        CREATE TABLE "${schema}".t (
+          literal_col varchar[] DEFAULT '{full_name,date_of_birth}',
+          empty_literal_col text[] DEFAULT '{}',
+          int_literal_col integer[] DEFAULT '{1,2}',
+          empty_array_col text[] DEFAULT ARRAY[]::text[],
+          function_col integer[] DEFAULT array_fill(0, ARRAY[3]),
+          array_col text[] DEFAULT ARRAY['a', 'b']
+        );
+      `);
+
+      const schemaJson = await connector.fetchSchemaJson(`${connection}?schemas=${schema}`, 'postgres');
+      const dbdefaults = Object.fromEntries(schemaJson.fields[`${schema}.t`].map(({ name, dbdefault }) => [name, dbdefault]));
+
+      expect(dbdefaults).toEqual({
+        literal_col: { type: 'string', value: '{full_name,date_of_birth}' },
+        empty_literal_col: { type: 'string', value: '{}' },
+        int_literal_col: { type: 'string', value: '{1,2}' },
+        empty_array_col: { type: 'expression', value: 'ARRAY[]::text[]' },
+        function_col: { type: 'expression', value: 'array_fill(0, ARRAY[3])' },
+        array_col: { type: 'expression', value: 'ARRAY[\'a\',  \'b\']' },
+      });
+    } finally {
+      await client.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+      await client.end();
+    }
+  });
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/connector",
-  "version": "10.4.0-alpha.1",
+  "version": "10.4.0-metadata-ref-type.0",
   "description": "This package was created to fetch the schema JSON from many kind of databases.",
   "author": "huy.phung.sw@gmail.com",
   "license": "MIT",
@@ -39,5 +39,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "2abacb40597047ca589b2c18117f57f8fe3978e6"
+  "gitHead": "f2806cfb089ae685523e444dd409fd1e4514962b"
 }

package/src/connectors/postgres/index.ts

@@ -54,7 +54,9 @@ const getFieldType = (data_type: string, udt_name: string, character_maximum_len
 };
 
 const getDbdefault = (data_type: string, column_default: string, default_type: DefaultType): DefaultInfo => {
-  if (data_type === 'ARRAY') {
+  // Only a non-empty ARRAY[...] constructor is rewritten here. Other array defaults, such as
+  // '{a,b}'::text[], ARRAY[]::text[] or a function call, are handled below like any other default
+  if (data_type === 'ARRAY' && column_default.startsWith('ARRAY[') && !column_default.startsWith('ARRAY[]')) {
     const values = column_default.slice(6, -1).split(',').map((value) => {
       return value.split('::')[0];
     });
@@ -228,40 +230,59 @@ const generateRawRefs = async (client: Client, schemas: string[]): Promise<Ref[]
 
   const refsListSql = `
     SELECT
-      tc.table_schema,
-      tc.table_name,
-      tc.constraint_name as fk_constraint_name,
-      STRING_AGG(DISTINCT kcu.column_name, ',') AS column_names,
-      ccu.table_schema AS foreign_table_schema,
-      ccu.table_name AS foreign_table_name,
-      STRING_AGG(DISTINCT ccu.column_name, ',') AS foreign_column_names,
-      tc.constraint_type,
-      rc.delete_rule AS on_delete,
-      rc.update_rule AS on_update
-    FROM information_schema.table_constraints AS tc
-    JOIN information_schema.key_column_usage AS kcu
-      ON tc.constraint_name = kcu.constraint_name
-      AND tc.table_schema = kcu.table_schema
-    JOIN information_schema.constraint_column_usage AS ccu
-      ON ccu.constraint_name = tc.constraint_name
-    JOIN information_schema.referential_constraints AS rc
-      ON tc.constraint_name = rc.constraint_name
-      AND tc.table_schema = rc.constraint_schema
-    WHERE tc.constraint_type = 'FOREIGN KEY'
-      AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')
-      ${buildSchemaQuery('tc.table_schema', schemas)}
+      source_ns.nspname AS table_schema,
+      source_table.relname AS table_name,
+      constraint_row.conname AS fk_constraint_name,
+      STRING_AGG(source_column.attname, ',' ORDER BY key_column.ordinality) AS column_names,
+      target_ns.nspname AS foreign_table_schema,
+      target_table.relname AS foreign_table_name,
+      STRING_AGG(target_column.attname, ',' ORDER BY key_column.ordinality) AS foreign_column_names,
+      CASE constraint_row.confdeltype
+        WHEN 'a' THEN 'NO ACTION'
+        WHEN 'r' THEN 'RESTRICT'
+        WHEN 'c' THEN 'CASCADE'
+        WHEN 'n' THEN 'SET NULL'
+        WHEN 'd' THEN 'SET DEFAULT'
+      END AS on_delete,
+      CASE constraint_row.confupdtype
+        WHEN 'a' THEN 'NO ACTION'
+        WHEN 'r' THEN 'RESTRICT'
+        WHEN 'c' THEN 'CASCADE'
+        WHEN 'n' THEN 'SET NULL'
+        WHEN 'd' THEN 'SET DEFAULT'
+      END AS on_update
+    FROM pg_constraint AS constraint_row
+    JOIN pg_class AS source_table
+      ON constraint_row.conrelid = source_table.oid
+    JOIN pg_namespace AS source_ns
+      ON source_table.relnamespace = source_ns.oid
+    JOIN pg_class AS target_table
+      ON constraint_row.confrelid = target_table.oid
+    JOIN pg_namespace AS target_ns
+      ON target_table.relnamespace = target_ns.oid
+    JOIN LATERAL unnest(constraint_row.conkey, constraint_row.confkey)
+      WITH ORDINALITY AS key_column(source_attnum, target_attnum, ordinality)
+      ON TRUE
+    JOIN pg_attribute AS source_column
+      ON source_column.attrelid = source_table.oid
+      AND source_column.attnum = key_column.source_attnum
+    JOIN pg_attribute AS target_column
+      ON target_column.attrelid = target_table.oid
+      AND target_column.attnum = key_column.target_attnum
+    WHERE constraint_row.contype = 'f'
+      AND source_ns.nspname NOT IN ('pg_catalog', 'information_schema')
+      ${buildSchemaQuery('source_ns.nspname', schemas)}
     GROUP BY
-      tc.table_schema,
-      tc.table_name,
-      tc.constraint_name,
-      ccu.table_schema,
-      ccu.table_name,
-      tc.constraint_type,
-      rc.delete_rule,
-      rc.update_rule
+      source_ns.nspname,
+      source_table.relname,
+      constraint_row.conname,
+      target_ns.nspname,
+      target_table.relname,
+      constraint_row.confdeltype,
+      constraint_row.confupdtype
     ORDER BY
-      tc.table_schema,
-      tc.table_name;
+      source_ns.nspname,
+      source_table.relname;
   `;
 
   const refsQueryResult = await client.query(refsListSql);