@dbml/cli 3.7.0 → 3.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/cli",
-  "version": "3.7.0",
+  "version": "3.7.1",
   "description": "",
   "main": "lib/index.js",
   "license": "Apache-2.0",
@@ -26,7 +26,7 @@
   ],
   "dependencies": {
     "@babel/cli": "^7.21.0",
-    "@dbml/core": "^3.7.0",
+    "@dbml/core": "^3.7.1",
     "bluebird": "^3.5.5",
     "chalk": "^2.4.2",
     "commander": "^2.20.0",
@@ -54,5 +54,8 @@
       "^.+\\.js$": "babel-jest"
     }
   },
-  "gitHead": "3222baa4bf45b9ff74711a63d376505cf4bd9ac0"
+  "gitHead": "71d7e2cd00ba5d60d2e36c465d43ce1d91189274",
+  "engines": {
+    "node": ">=18"
+  }
 }

package/lib/connectors/Connector.js

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.fetchSchemaJson = void 0;
-var _PostgresConnector = require("./PostgresConnector");
-var _MssqlConnector = require("./MssqlConnector");
-const fetchSchemaJson = async (connection, format) => {
-  switch (format) {
-    case 'postgres':
-      return (0, _PostgresConnector.fetchSchemaJson)(connection);
-    case 'mssql':
-      return (0, _MssqlConnector.fetchSchemaJson)(connection);
-    default:
-      throw new Error(`Unsupported connection format: ${format}`);
-  }
-};
-exports.fetchSchemaJson = fetchSchemaJson;

package/lib/connectors/MssqlConnector.js

@@ -1,483 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.fetchSchemaJson = void 0;
-var _mssql = _interopRequireDefault(require("mssql"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/* eslint-disable camelcase */
-
-const MSSQL_DATE_TYPES = ['date', 'datetime', 'datetime2', 'smalldatetime', 'datetimeoffset', 'time'];
-const connect = async connection => {
-  const options = connection.split(';').reduce((acc, option) => {
-    const [key, value] = option.split('=');
-    acc[key] = value;
-    return acc;
-  }, {});
-  const [host, port] = options['Data Source'].split(',');
-  const config = {
-    user: options['User ID'],
-    password: options.Password,
-    server: host,
-    database: options['Initial Catalog'],
-    options: {
-      encrypt: options.Encrypt === 'True',
-      trustServerCertificate: options['Trust Server Certificate'] === 'True',
-      port: port || 1433
-    }
-  };
-  try {
-    // Connect to the database using the connection string
-    const client = await _mssql.default.connect(config);
-    return client;
-  } catch (err) {
-    console.log('MSSQL connection error:', err);
-    return null;
-  }
-};
-const convertQueryBoolean = val => val === 'YES';
-const getFieldType = (data_type, default_type, character_maximum_length, numeric_precision, numeric_scale) => {
-  if (MSSQL_DATE_TYPES.includes(data_type)) {
-    return data_type;
-  }
-  if (data_type === 'bit') {
-    return data_type;
-  }
-  if (numeric_precision && numeric_scale && default_type === 'number') {
-    return `${data_type}(${numeric_precision},${numeric_scale})`;
-  }
-  if (character_maximum_length && character_maximum_length > 0 && default_type === 'string') {
-    return `${data_type}(${character_maximum_length})`;
-  }
-  return data_type;
-};
-const getDbdefault = (data_type, column_default, default_type) => {
-  // The regex below is used to extract the value from the default value
-  // \( and \) are used to escape parentheses
-  // [^()]+ is used to match any character except parentheses
-  // Example: (1) => 1, ('hello') => hello, getdate()-(1) => getdate()-1
-  const value = column_default.slice(1, -1).replace(/\(([^()]+)\)/g, '$1');
-  return {
-    type: default_type,
-    value: default_type === 'string' ? value.slice(1, -1) : value // Remove the quotes for string values
-  };
-};
-
-const getEnumValues = definition => {
-  // Use the example below to understand the regex:
-  // ([quantity]>(0))
-  // ([unit_price]>(0))
-  // ([status]='cancelled' OR [status]='delivered' OR [status]='shipped' OR [status]='processing' OR [status]='pending')
-  // ([total_amount]>(0))
-  // ([price]>(0))
-  // ([stock_quantity]>=(0))
-  // ([age_start]<=[age_end])
-  // ([age_start]<=[age_end])
-  // ([gender]='Other' OR [gender]='Female' OR [gender]='Male')
-  // ([date_of_birth]<=dateadd(year,(-13),getdate()))
-  // ([email] like '%_@_%._%')
-  if (!definition) return null;
-  const values = definition.match(/\[([^\]]+)\]='([^']+)'/g); // Extracting the enum values when the definition contains ]='
-  if (!values) return null;
-  const enumValues = values.map(value => {
-    const enumValue = value.split("]='")[1];
-    return {
-      name: enumValue.slice(0, -1)
-    };
-  });
-  return enumValues;
-};
-const generateField = row => {
-  const {
-    column_name,
-    data_type,
-    character_maximum_length,
-    numeric_precision,
-    numeric_scale,
-    identity_increment,
-    is_nullable,
-    column_default,
-    default_type,
-    column_comment
-  } = row;
-  const dbdefault = column_default && default_type !== 'increment' ? getDbdefault(data_type, column_default, default_type) : null;
-  const fieldType = {
-    type_name: getFieldType(data_type, default_type, character_maximum_length, numeric_precision, numeric_scale),
-    schemaname: null
-  };
-  return {
-    name: column_name,
-    type: fieldType,
-    dbdefault,
-    not_null: !convertQueryBoolean(is_nullable),
-    increment: !!identity_increment,
-    note: column_comment ? {
-      value: column_comment
-    } : {
-      value: ''
-    }
-  };
-};
-const generateTablesFieldsAndEnums = async client => {
-  const fields = {};
-  const enums = [];
-  const tablesAndFieldsSql = `
-    WITH tables_and_fields AS (
-        SELECT
-            s.name AS table_schema,
-            t.name AS table_name,
-            c.name AS column_name,
-            ty.name AS data_type,
-            c.max_length AS character_maximum_length,
-            c.precision AS numeric_precision,
-            c.scale AS numeric_scale,
-            c.is_identity AS identity_increment,
-            CASE
-                WHEN c.is_nullable = 1 THEN 'YES'
-                ELSE 'NO'
-            END AS is_nullable,
-            CASE
-                WHEN c.default_object_id = 0 THEN NULL
-                ELSE OBJECT_DEFINITION(c.default_object_id)
-            END AS column_default,
-            -- Fetching table comments
-            p.value AS table_comment,
-            ep.value AS column_comment
-        FROM
-            sys.tables t
-        JOIN
-            sys.schemas s ON t.schema_id = s.schema_id
-        JOIN
-            sys.columns c ON t.object_id = c.object_id
-        JOIN
-            sys.types ty ON c.user_type_id = ty.user_type_id
-        LEFT JOIN
-            sys.extended_properties p ON p.major_id = t.object_id
-                AND p.name = 'MS_Description'
-                AND p.minor_id = 0 -- Ensure minor_id is 0 for table comments
-        LEFT JOIN
-            sys.extended_properties ep ON ep.major_id = c.object_id
-                AND ep.minor_id = c.column_id
-                AND ep.name = 'MS_Description'
-        WHERE
-            t.type = 'U' -- User-defined tables
-    )
-    SELECT
-        tf.table_schema,
-        tf.table_name,
-        tf.column_name,
-        tf.data_type,
-        tf.character_maximum_length,
-        tf.numeric_precision,
-        tf.numeric_scale,
-        tf.identity_increment,
-        tf.is_nullable,
-        tf.column_default,
-        tf.table_comment,
-        tf.column_comment,
-        cc.name AS check_constraint_name, -- Adding CHECK constraint name
-        cc.definition AS check_constraint_definition, -- Adding CHECK constraint definition
-        CASE
-            WHEN tf.column_default LIKE '((%))' THEN 'number'
-            WHEN tf.column_default LIKE '(''%'')' THEN 'string'
-            ELSE 'expression'
-        END AS default_type
-    FROM
-        tables_and_fields AS tf
-    LEFT JOIN
-        sys.check_constraints cc ON cc.parent_object_id = OBJECT_ID(tf.table_schema + '.' + tf.table_name)
-        AND cc.definition LIKE '%' + tf.column_name + '%' -- Ensure the constraint references the column
-    ORDER BY
-        tf.table_schema,
-        tf.table_name,
-        tf.column_name;
-  `;
-  const tablesAndFieldsResult = await client.query(tablesAndFieldsSql);
-  const tables = tablesAndFieldsResult.recordset.reduce((acc, row) => {
-    const {
-      table_schema,
-      table_name,
-      table_comment,
-      check_constraint_name,
-      check_constraint_definition
-    } = row;
-    if (!acc[table_name]) {
-      acc[table_name] = {
-        name: table_name,
-        schemaName: table_schema,
-        note: table_comment ? {
-          value: table_comment
-        } : {
-          value: ''
-        }
-      };
-    }
-    const enumValues = getEnumValues(check_constraint_definition);
-    if (enumValues) {
-      enums.push({
-        name: check_constraint_name,
-        schemaName: table_schema,
-        values: enumValues
-      });
-    }
-    if (!fields[table_name]) fields[table_name] = [];
-    const field = generateField(row);
-    if (enumValues) {
-      field.type = {
-        type_name: check_constraint_name,
-        schemaName: table_schema
-      };
-    }
-    fields[table_name].push(field);
-    return acc;
-  }, {});
-  return {
-    tables: Object.values(tables),
-    fields,
-    enums
-  };
-};
-const generateRefs = async client => {
-  const refs = [];
-  const refsListSql = `
-    SELECT
-      s.name AS table_schema,
-      t.name AS table_name,
-      fk.name AS fk_constraint_name,
-      STUFF((
-        SELECT ',' + c1.name
-        FROM sys.foreign_key_columns AS fkc
-        JOIN sys.columns AS c1 ON fkc.parent_object_id = c1.object_id AND fkc.parent_column_id = c1.column_id
-        WHERE fkc.constraint_object_id = fk.object_id
-        FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'), 1, 1, '') AS column_names,
-      s2.name AS foreign_table_schema,
-      t2.name AS foreign_table_name,
-      STUFF((
-        SELECT ',' + c2.name
-        FROM sys.foreign_key_columns AS fkc
-        JOIN sys.columns AS c2 ON fkc.referenced_object_id = c2.object_id AND fkc.referenced_column_id = c2.column_id
-        WHERE fkc.constraint_object_id = fk.object_id
-        FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'), 1, 1, '') AS foreign_column_names,
-      fk.type_desc AS constraint_type,
-      fk.delete_referential_action_desc AS on_delete,
-      fk.update_referential_action_desc AS on_update
-    FROM sys.foreign_keys AS fk
-    JOIN sys.tables AS t ON fk.parent_object_id = t.object_id
-    JOIN sys.schemas AS s ON t.schema_id = s.schema_id
-    JOIN sys.tables AS t2 ON fk.referenced_object_id = t2.object_id
-    JOIN sys.schemas AS s2 ON t2.schema_id = s2.schema_id
-    WHERE s.name NOT IN ('sys', 'information_schema')
-    ORDER BY
-      s.name,
-      t.name;
-  `;
-  const refsQueryResult = await client.query(refsListSql);
-  refsQueryResult.recordset.forEach(refRow => {
-    const {
-      table_schema,
-      fk_constraint_name,
-      table_name,
-      column_names,
-      foreign_table_schema,
-      foreign_table_name,
-      foreign_column_names,
-      on_delete,
-      on_update
-    } = refRow;
-    const ep1 = {
-      tableName: table_name,
-      schemaName: table_schema,
-      fieldNames: column_names.split(','),
-      relation: '*'
-    };
-    const ep2 = {
-      tableName: foreign_table_name,
-      schemaName: foreign_table_schema,
-      fieldNames: foreign_column_names.split(','),
-      relation: '1'
-    };
-    refs.push({
-      name: fk_constraint_name,
-      endpoints: [ep1, ep2],
-      onDelete: on_delete === 'NO_ACTION' ? null : on_delete,
-      onUpdate: on_update === 'NO_ACTION' ? null : on_update
-    });
-  });
-  return refs;
-};
-const generateIndexes = async client => {
-  const indexListSql = `
-    WITH user_tables AS (
-      SELECT
-        TABLE_NAME
-      FROM
-        INFORMATION_SCHEMA.TABLES
-      WHERE
-        TABLE_SCHEMA = 'dbo'
-        AND TABLE_TYPE = 'BASE TABLE'  -- Ensure we are only getting base tables
-        AND TABLE_NAME NOT LIKE 'dt%'
-        AND TABLE_NAME NOT LIKE 'syscs%'
-        AND TABLE_NAME NOT LIKE 'sysss%'
-        AND TABLE_NAME NOT LIKE 'sysrs%'
-        AND TABLE_NAME NOT LIKE 'sysxlgc%'
-    ),
-    index_info AS (
-      SELECT
-        OBJECT_NAME(i.object_id) AS table_name,
-        i.name AS index_name,
-        i.is_unique,
-        CASE
-          WHEN i.type = 1 THEN 1
-          ELSE 0
-        END AS is_primary,
-        i.type_desc AS index_type,
-        STUFF((
-          SELECT
-            ', ' + c.name
-          FROM
-            sys.index_columns ic
-            JOIN sys.columns c ON ic.column_id = c.column_id AND ic.object_id = c.object_id
-          WHERE
-            ic.index_id = i.index_id
-            AND ic.object_id = i.object_id
-            AND OBJECT_NAME(ic.object_id) IN (SELECT TABLE_NAME FROM user_tables)  -- Filter for user tables
-          ORDER BY
-            ic.key_ordinal
-          FOR XML PATH('')
-        ), 1, 2, '') AS columns,
-        CASE
-          WHEN i.type = 1 THEN 'PRIMARY KEY'
-          WHEN i.is_unique = 1 THEN 'UNIQUE'
-          ELSE NULL
-        END AS constraint_type
-      FROM
-        sys.indexes i
-        JOIN sys.tables t ON i.object_id = t.object_id
-      WHERE
-        t.is_ms_shipped = 0
-        AND i.type <> 0
-    )
-    SELECT
-      ut.TABLE_NAME AS table_name,
-      ii.index_name,
-      ii.is_unique,
-      ii.is_primary,
-      ii.index_type,
-      ii.columns,
-      ii.constraint_type
-    FROM
-      user_tables ut
-    LEFT JOIN
-      index_info ii ON ut.TABLE_NAME = ii.table_name
-    WHERE
-      ii.columns IS NOT NULL
-    ORDER BY
-      ut.TABLE_NAME,
-      ii.constraint_type,
-      ii.index_name;
-  `;
-  const indexListResult = await client.query(indexListSql);
-  const {
-    outOfLineConstraints,
-    inlineConstraints
-  } = indexListResult.recordset.reduce((acc, row) => {
-    const {
-      constraint_type,
-      columns
-    } = row;
-    if (columns === 'null' || columns.trim() === '') return acc;
-    if (constraint_type === 'PRIMARY KEY' || constraint_type === 'UNIQUE') {
-      acc.inlineConstraints.push(row);
-    } else {
-      acc.outOfLineConstraints.push(row);
-    }
-    return acc;
-  }, {
-    outOfLineConstraints: [],
-    inlineConstraints: []
-  });
-  const indexes = outOfLineConstraints.reduce((acc, indexRow) => {
-    const {
-      table_name,
-      index_name,
-      index_type,
-      columns,
-      expressions
-    } = indexRow;
-    const indexColumns = columns.split(',').map(column => {
-      return {
-        type: 'column',
-        value: column.trim()
-      };
-    });
-    const indexExpressions = expressions ? expressions.split(',').map(expression => {
-      return {
-        type: 'expression',
-        value: expression
-      };
-    }) : [];
-    const index = {
-      name: index_name,
-      type: index_type,
-      columns: [...indexColumns, ...indexExpressions]
-    };
-    if (acc[table_name]) {
-      acc[table_name].push(index);
-    } else {
-      acc[table_name] = [index];
-    }
-    return acc;
-  }, {});
-  const tableConstraints = inlineConstraints.reduce((acc, row) => {
-    const {
-      table_name,
-      columns,
-      constraint_type
-    } = row;
-    if (!acc[table_name]) acc[table_name] = {};
-    const columnNames = columns.split(',').map(column => column.trim());
-    columnNames.forEach(columnName => {
-      if (!acc[table_name][columnName]) acc[table_name][columnName] = {};
-      if (constraint_type === 'PRIMARY KEY') {
-        acc[table_name][columnName].pk = true;
-      }
-      if (constraint_type === 'UNIQUE' && !acc[table_name][columnName].pk) {
-        acc[table_name][columnName].unique = true;
-      }
-    });
-    return acc;
-  }, {});
-  return {
-    indexes,
-    tableConstraints
-  };
-};
-const fetchSchemaJson = async connection => {
-  const client = await connect(connection);
-  if (!client) throw new Error('Failed to connect to the database');
-  const tablesFieldsAndEnumsRes = generateTablesFieldsAndEnums(client);
-  const indexesRes = generateIndexes(client);
-  const refsRes = generateRefs(client);
-  const res = await Promise.all([tablesFieldsAndEnumsRes, indexesRes, refsRes]);
-  client.close();
-  const {
-    tables,
-    fields,
-    enums
-  } = res[0];
-  const {
-    indexes,
-    tableConstraints
-  } = res[1];
-  const refs = res[2];
-  return {
-    tables,
-    fields,
-    enums,
-    refs,
-    indexes,
-    tableConstraints
-  };
-};
-exports.fetchSchemaJson = fetchSchemaJson;

package/lib/connectors/PostgresConnector.js

@@ -1,450 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.fetchSchemaJson = void 0;
-var _pg = require("pg");
-/* eslint-disable camelcase */
-
-const connectPg = async connection => {
-  const client = new _pg.Client(connection);
-  // bearer:disable javascript_lang_logger
-  client.on('error', err => console.log('PG connection error:', err));
-  await client.connect();
-  return client;
-};
-const convertQueryBoolean = val => val === 'YES';
-const getFieldType = (data_type, udt_name, character_maximum_length, numeric_precision, numeric_scale) => {
-  if (data_type === 'ARRAY') {
-    return `${udt_name.slice(1, udt_name.length)}[]`;
-  }
-  if (character_maximum_length) {
-    return `${udt_name}(${character_maximum_length})`;
-  }
-  if (numeric_precision && numeric_scale) {
-    return `${udt_name}(${numeric_precision},${numeric_scale})`;
-  }
-  return udt_name;
-};
-const getDbdefault = (data_type, column_default, default_type) => {
-  if (data_type === 'ARRAY') {
-    const values = column_default.slice(6, -1).split(',').map(value => {
-      return value.split('::')[0];
-    });
-    return {
-      type: default_type,
-      value: `ARRAY[${values.join(', ')}]`
-    };
-  }
-  if (default_type === 'string') {
-    const defaultValues = column_default.split('::')[0];
-    const isJson = data_type === 'json' || data_type === 'jsonb';
-    const type = isJson ? 'expression' : 'string';
-    return {
-      type,
-      value: defaultValues.slice(1, -1)
-    };
-  }
-  return {
-    type: default_type,
-    value: column_default
-  };
-};
-const generateField = row => {
-  const {
-    column_name,
-    data_type,
-    character_maximum_length,
-    numeric_precision,
-    numeric_scale,
-    udt_schema,
-    udt_name,
-    identity_increment,
-    is_nullable,
-    column_default,
-    default_type,
-    column_comment
-  } = row;
-  const dbdefault = column_default && default_type !== 'increment' ? getDbdefault(data_type, column_default, default_type) : null;
-  const fieldType = data_type === 'USER-DEFINED' ? {
-    type_name: udt_name,
-    schemaName: udt_schema
-  } : {
-    type_name: getFieldType(data_type, udt_name, character_maximum_length, numeric_precision, numeric_scale),
-    schemaname: null
-  };
-  return {
-    name: column_name,
-    type: fieldType,
-    dbdefault,
-    not_null: !convertQueryBoolean(is_nullable),
-    increment: !!identity_increment || default_type === 'increment',
-    note: column_comment ? {
-      value: column_comment
-    } : {
-      value: ''
-    }
-  };
-};
-const generateTablesAndFields = async client => {
-  const fields = {};
-  const tablesAndFieldsSql = `
-    WITH comments AS (
-      SELECT
-        pc.relname AS table_name,
-        pn.nspname AS table_schema,
-        pa.attname AS column_name,
-        pd.description
-      FROM
-        pg_description pd
-      JOIN
-        pg_class pc ON pd.objoid = pc.oid
-      JOIN
-        pg_namespace pn ON pc.relnamespace = pn.oid
-      LEFT JOIN
-        pg_attribute pa ON pd.objoid = pa.attrelid AND pd.objsubid = pa.attnum
-      WHERE
-        pc.relkind = 'r'
-        AND pn.nspname NOT IN ('pg_catalog', 'information_schema')
-    )
-    SELECT
-      t.table_schema,
-      t.table_name,
-      c.column_name,
-      c.data_type,
-      c.character_maximum_length,
-      c.numeric_precision,
-      c.numeric_scale,
-      c.udt_schema,
-      c.udt_name,
-      c.identity_increment,
-      c.is_nullable,
-      c.column_default,
-      CASE
-        WHEN c.column_default IS NULL THEN NULL
-        WHEN c.column_default LIKE 'nextval(%' THEN 'increment'
-        WHEN c.column_default LIKE '''%' THEN 'string'
-        WHEN c.column_default = 'true' OR c.column_default = 'false' THEN 'boolean'
-        WHEN c.column_default ~ '^-?[0-9]+(.[0-9]+)?$' THEN 'number'
-        ELSE 'expression'
-      END AS default_type,
-      (SELECT description FROM comments WHERE table_name = t.table_name AND table_schema = t.table_schema AND column_name IS NULL) AS table_comment,
-      (SELECT description FROM comments WHERE table_name = t.table_name AND table_schema = t.table_schema AND column_name = c.column_name) AS column_comment
-    FROM
-      information_schema.columns c
-    JOIN
-      information_schema.tables t ON c.table_name = t.table_name AND c.table_schema = t.table_schema
-    WHERE
-      t.table_type = 'BASE TABLE'
-      AND t.table_schema NOT IN ('pg_catalog', 'information_schema')
-    ORDER BY
-      t.table_schema,
-      t.table_name,
-      c.ordinal_position
-    ;
-  `;
-  const tablesAndFieldsResult = await client.query(tablesAndFieldsSql);
-  const tables = tablesAndFieldsResult.rows.reduce((acc, row) => {
-    const {
-      table_schema,
-      table_name,
-      table_comment
-    } = row;
-    if (!acc[table_name]) {
-      acc[table_name] = {
-        name: table_name,
-        schemaName: table_schema,
-        note: table_comment ? {
-          value: table_comment
-        } : {
-          value: ''
-        }
-      };
-    }
-    if (!fields[table_name]) fields[table_name] = [];
-    const field = generateField(row);
-    fields[table_name].push(field);
-    return acc;
-  }, {});
-  return {
-    tables: Object.values(tables),
-    fields
-  };
-};
-const generateRawRefs = async client => {
-  const refs = [];
-  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')
-    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
-    ORDER BY
-      tc.table_schema,
-      tc.table_name;
-  `;
-  const refsQueryResult = await client.query(refsListSql);
-  refsQueryResult.rows.forEach(refRow => {
-    const {
-      table_schema,
-      fk_constraint_name,
-      table_name,
-      column_names,
-      foreign_table_schema,
-      foreign_table_name,
-      foreign_column_names,
-      on_delete,
-      on_update
-    } = refRow;
-    const ep1 = {
-      tableName: table_name,
-      schemaName: table_schema,
-      fieldNames: column_names.split(','),
-      relation: '*'
-    };
-    const ep2 = {
-      tableName: foreign_table_name,
-      schemaName: foreign_table_schema,
-      fieldNames: foreign_column_names.split(','),
-      relation: '1'
-    };
-    refs.push({
-      name: fk_constraint_name,
-      endpoints: [ep1, ep2],
-      onDelete: on_delete === 'NO ACTION' ? null : on_delete,
-      onUpdate: on_update === 'NO ACTION' ? null : on_update
-    });
-  });
-  return refs;
-};
-const generateIndexes = async client => {
-  // const tableConstraints = {};
-  const indexListSql = `
-    WITH user_tables AS (
-      SELECT tablename
-      FROM pg_tables
-      WHERE schemaname NOT IN ('pg_catalog', 'information_schema')  -- Exclude system schemas
-        AND tablename NOT LIKE 'pg_%'  -- Exclude PostgreSQL system tables
-        AND tablename NOT LIKE 'sql_%'  -- Exclude SQL standard tables
-    ),
-    index_info AS (
-      SELECT
-        t.relname AS table_name,
-        i.relname AS index_name,
-        ix.indisunique AS is_unique,
-        ix.indisprimary AS is_primary,
-        am.amname AS index_type,
-        array_to_string(array_agg(a.attname ORDER BY x.n), ', ') AS columns,
-        pg_get_expr(ix.indexprs, ix.indrelid) AS expressions,
-        CASE
-          WHEN ix.indisprimary THEN 'PRIMARY KEY'
-          WHEN ix.indisunique THEN 'UNIQUE'
-          ELSE NULL
-        END AS constraint_type
-      FROM
-        pg_class t
-        JOIN pg_index ix ON t.oid = ix.indrelid
-        JOIN pg_class i ON i.oid = ix.indexrelid
-        LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
-        JOIN pg_am am ON i.relam = am.oid
-        LEFT JOIN generate_subscripts(ix.indkey, 1) AS x(n) ON a.attnum = ix.indkey[x.n]
-      WHERE
-        t.relkind = 'r'
-        AND t.relname NOT LIKE 'pg_%'
-        AND t.relname NOT LIKE 'sql_%'
-      GROUP BY
-        t.relname, i.relname, ix.indisunique, ix.indisprimary, am.amname, ix.indexprs, ix.indrelid
-    )
-    SELECT
-      ut.tablename AS table_name,
-      ii.index_name,
-      ii.is_unique,
-      ii.is_primary,
-      ii.index_type,
-      ii.columns,
-      ii.expressions,
-      ii.constraint_type  -- Added constraint type
-    FROM
-      user_tables ut
-    LEFT JOIN
-      index_info ii ON ut.tablename = ii.table_name
-    WHERE ii.columns IS NOT NULL
-    ORDER BY
-      ut.tablename,
-      ii.constraint_type,
-      ii.index_name
-    ;
-  `;
-  const indexListResult = await client.query(indexListSql);
-  const {
-    outOfLineConstraints,
-    inlineConstraints
-  } = indexListResult.rows.reduce((acc, row) => {
-    const {
-      constraint_type,
-      columns
-    } = row;
-    if (columns === 'null' || columns.trim() === '') return acc;
-    const isSingleColumn = columns.split(',').length === 1;
-    const isInlineConstraint = isSingleColumn && (constraint_type === 'PRIMARY KEY' || constraint_type === 'UNIQUE');
-    if (isInlineConstraint) {
-      acc.inlineConstraints.push(row);
-    } else {
-      acc.outOfLineConstraints.push(row);
-    }
-    return acc;
-  }, {
-    outOfLineConstraints: [],
-    inlineConstraints: []
-  });
-  const indexes = outOfLineConstraints.reduce((acc, indexRow) => {
-    const {
-      table_name,
-      index_name,
-      index_type,
-      columns,
-      expressions
-    } = indexRow;
-    const indexColumns = columns.split(',').map(column => {
-      return {
-        type: 'column',
-        value: column.trim()
-      };
-    });
-    const indexExpressions = expressions ? expressions.split(',').map(expression => {
-      return {
-        type: 'expression',
-        value: expression
-      };
-    }) : [];
-    const index = {
-      name: index_name,
-      type: index_type,
-      columns: [...indexColumns, ...indexExpressions]
-    };
-    if (acc[table_name]) {
-      acc[table_name].push(index);
-    } else {
-      acc[table_name] = [index];
-    }
-    return acc;
-  }, {});
-  const tableConstraints = inlineConstraints.reduce((acc, row) => {
-    const {
-      table_name,
-      columns,
-      constraint_type
-    } = row;
-    if (!acc[table_name]) acc[table_name] = {};
-    const columnNames = columns.split(',').map(column => column.trim());
-    columnNames.forEach(columnName => {
-      if (!acc[table_name][columnName]) acc[table_name][columnName] = {};
-      if (constraint_type === 'PRIMARY KEY') {
-        acc[table_name][columnName].pk = true;
-      }
-      if (constraint_type === 'UNIQUE' && !acc[table_name][columnName].pk) {
-        acc[table_name][columnName].unique = true;
-      }
-    });
-    return acc;
-  }, {});
-  return {
-    indexes,
-    tableConstraints
-  };
-};
-const generateRawEnums = async client => {
-  const enumListSql = `
-    SELECT
-      n.nspname AS schema_name,
-      t.typname AS enum_type,
-      e.enumlabel AS enum_value,
-      e.enumsortorder AS sort_order
-    FROM
-      pg_enum e
-    JOIN
-      pg_type t ON e.enumtypid = t.oid
-    JOIN
-      pg_namespace n ON t.typnamespace = n.oid
-    ORDER BY
-      schema_name,
-      enum_type,
-      sort_order;
-    ;
-  `;
-  const enumListResult = await client.query(enumListSql);
-  const enums = enumListResult.rows.reduce((acc, row) => {
-    const {
-      schema_name,
-      enum_type,
-      enum_value
-    } = row;
-    if (!acc[enum_type]) {
-      acc[enum_type] = {
-        name: enum_type,
-        schemaName: schema_name,
-        values: []
-      };
-    }
-    acc[enum_type].values.push({
-      name: enum_value
-    });
-    return acc;
-  }, {});
-  return Object.values(enums);
-};
-const fetchSchemaJson = async connection => {
-  const client = await connectPg(connection);
-  const tablesAndFieldsRes = generateTablesAndFields(client);
-  const indexesRes = generateIndexes(client);
-  const refsRes = generateRawRefs(client);
-  const enumsRes = generateRawEnums(client);
-  const res = await Promise.all([tablesAndFieldsRes, indexesRes, refsRes, enumsRes]);
-  client.end();
-  const {
-    tables,
-    fields
-  } = res[0];
-  const {
-    indexes,
-    tableConstraints
-  } = res[1];
-  const refs = res[2];
-  const enums = res[3];
-  return {
-    tables,
-    fields,
-    refs,
-    enums,
-    indexes,
-    tableConstraints
-  };
-};
-exports.fetchSchemaJson = fetchSchemaJson;