@dbml/connector 5.0.0-alpha.0 → 5.1.0

package/dist/connectors/mssqlConnector.js

@@ -5,6 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchSchemaJson = void 0;
 /* eslint-disable camelcase */
+/* TDD 72
+ * - In MSSQL, there's no notion of ENUM.
+ * - MSSQL connector used to extract ENUMS from CHECK constraints, for example: `CHECK ([col]=value1 OR [col]=value2)` would be translated to an enum with 2 values, `value1` and `value2`.
+ * - Since DBML 4.0.0, we have supported CHECK constraints, so we no longer extract ENUMS out from CHECK constraints but rather keep them as CHECK constraints.
+ * */
 const mssql_1 = __importDefault(require("mssql"));
 const parseSchema_1 = require("../utils/parseSchema");
 // https://learn.microsoft.com/en-us/sql/t-sql/data-types/date-and-time-types?view=sql-server-ver15
@@ -88,63 +93,6 @@ const getDbdefault = (data_type, column_default, default_type) => {
         value: default_type === 'string' ? value.slice(1, -1) : value, // Remove the quotes for string values
     };
 };
-const getEnumValues = (definition, constraint_name) => {
-    // 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 [];
-    const values = definition.match(/\[([^\]]+)\]='([^']+)'/g); // Extracting the enum values when the definition contains ]='
-    if (!values)
-        return [];
-    const colMap = {};
-    values.forEach((value) => {
-        const [columnName, enumValue] = value.split("]='");
-        const cleanColumnName = columnName.slice(1); // Remove the leading '['
-        const cleanEnumValue = enumValue.slice(0, -1); // Remove the trailing "'"
-        if (!colMap[cleanColumnName]) {
-            colMap[cleanColumnName] = [cleanEnumValue];
-        }
-        else {
-            colMap[cleanColumnName].push(cleanEnumValue);
-        }
-    });
-    const arraysEqual = (a, b) => {
-        if (a.length !== b.length)
-            return false;
-        const sortedA = [...a].sort();
-        const sortedB = [...b].sort();
-        return sortedA.every((value, index) => value === sortedB[index]);
-    };
-    // Please check the comments of the EnumValuesDict type in types.ts to understand the structure
-    const result = [];
-    const processedKeys = new Set();
-    Object.keys(colMap).forEach((key) => {
-        if (processedKeys.has(key))
-            return;
-        const mergedColumns = [key];
-        const colValues = colMap[key];
-        Object.keys(colMap).forEach((innerKey) => {
-            if (key !== innerKey && arraysEqual(colValues, colMap[innerKey])) {
-                mergedColumns.push(innerKey);
-                processedKeys.add(innerKey);
-            }
-        });
-        const enumValues = colValues.map((value) => ({ name: value }));
-        result.push({ columns: mergedColumns, enumValues, constraint_name: `${constraint_name}_${mergedColumns.join('_')}` });
-        processedKeys.add(key);
-    });
-    return result;
-};
 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;
@@ -161,10 +109,8 @@ const generateField = (row) => {
         note: column_comment ? { value: column_comment } : { value: '' },
     };
 };
-const generateTablesFieldsAndEnums = async (client, schemas) => {
-    const checkConstraintDefinitionDedup = {};
+const generateTablesFields = async (client, schemas) => {
     const fields = {};
-    const enums = [];
     const tablesAndFieldsSql = `
     WITH tables_and_fields AS (
       SELECT
@@ -203,35 +149,6 @@ const generateTablesFieldsAndEnums = async (client, schemas) => {
           AND ep.name like '%description%'
       WHERE
         t.type = 'U' -- User-defined tables
-    ),
-    constraints_with_nulls AS (
-      SELECT
-        tf.*,
-        cc.name AS check_constraint_name,
-        CASE
-          WHEN cc.definition LIKE '%[' + tf.column_name + ']%=''%' THEN cc.definition
-          ELSE NULL
-        END AS check_constraint_definition
-      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
-    ),
-    constraints_with_row_number AS (
-      SELECT
-        *,
-        ROW_NUMBER() OVER (
-          PARTITION BY table_schema, table_name, column_name
-          ORDER BY
-            CASE
-              WHEN check_constraint_definition IS NOT NULL THEN 1
-              ELSE 2
-            END,
-            check_constraint_name
-        ) AS rn
-      FROM
-        constraints_with_nulls
     )
     SELECT
       table_schema,
@@ -246,17 +163,15 @@ const generateTablesFieldsAndEnums = async (client, schemas) => {
       column_default,
       table_comment,
       column_comment,
-      check_constraint_name,
-      check_constraint_definition,
       CASE
         WHEN column_default LIKE '((%))' THEN 'number'
         WHEN column_default LIKE '(''%'')' THEN 'string'
         ELSE 'expression'
       END AS default_type
     FROM
-      constraints_with_row_number
+      tables_and_fields
     WHERE
-      rn = 1
+      1 = 1
       ${(0, parseSchema_1.buildSchemaQuery)('table_schema', schemas)}
     ORDER BY
       table_schema,
@@ -266,7 +181,7 @@ const generateTablesFieldsAndEnums = async (client, schemas) => {
   `;
     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;
+        const { table_schema, table_name, table_comment, } = row;
         const key = `${table_schema}.${table_name}`;
         if (!acc[key]) {
             acc[key] = {
@@ -278,34 +193,12 @@ const generateTablesFieldsAndEnums = async (client, schemas) => {
         if (!fields[key])
             fields[key] = [];
         const field = generateField(row);
-        if (check_constraint_definition && !checkConstraintDefinitionDedup[check_constraint_name]) {
-            const enumValuesByColumns = getEnumValues(check_constraint_definition, check_constraint_name);
-            enumValuesByColumns.forEach((item) => {
-                enums.push({
-                    name: item.constraint_name,
-                    schemaName: table_schema,
-                    values: item.enumValues,
-                });
-            });
-            checkConstraintDefinitionDedup[check_constraint_name] = enumValuesByColumns;
-        }
-        if (checkConstraintDefinitionDedup[check_constraint_name]) {
-            const enumValuesByColumns = checkConstraintDefinitionDedup[check_constraint_name];
-            const columnEnumValues = enumValuesByColumns.find((item) => item.columns.includes(field.name));
-            if (columnEnumValues) {
-                field.type = {
-                    type_name: columnEnumValues.constraint_name,
-                    schemaName: table_schema,
-                };
-            }
-        }
         fields[key].push(field);
         return acc;
     }, {});
     return {
         tables: Object.values(tables),
         fields,
-        enums,
     };
 };
 const generateRefs = async (client, schemas) => {
@@ -379,7 +272,7 @@ const generateRefs = async (client, schemas) => {
     });
     return refs;
 };
-const generateIndexes = async (client, schemas) => {
+const generateIndexesAndConstraints = async (client, schemas) => {
     const indexListSql = `
     WITH user_tables AS (
       SELECT
@@ -455,19 +348,19 @@ const generateIndexes = async (client, schemas) => {
       ii.index_name;
   `;
     const indexListResult = await client.query(indexListSql);
-    const { outOfLineConstraints, inlineConstraints } = indexListResult.recordset.reduce((acc, row) => {
+    const { outOfLineIndexes, inlineIndexes } = 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);
+            acc.inlineIndexes.push(row);
         }
         else {
-            acc.outOfLineConstraints.push(row);
+            acc.outOfLineIndexes.push(row);
         }
         return acc;
-    }, { outOfLineConstraints: [], inlineConstraints: [] });
-    const indexes = outOfLineConstraints.reduce((acc, indexRow) => {
+    }, { inlineIndexes: [], outOfLineIndexes: [] });
+    const indexes = outOfLineIndexes.reduce((acc, indexRow) => {
         const { table_schema, table_name, index_name, index_type, columns, expressions, } = indexRow;
         const indexColumns = columns.split(',').map((column) => {
             return {
@@ -498,51 +391,88 @@ const generateIndexes = async (client, schemas) => {
         }
         return acc;
     }, {});
-    const tableConstraints = inlineConstraints.reduce((acc, row) => {
+    const tableConstraints = {};
+    inlineIndexes.forEach((row) => {
         const { table_schema, table_name, columns, constraint_type, } = row;
         const key = `${table_schema}.${table_name}`;
-        if (!acc[key])
-            acc[key] = {};
+        if (!tableConstraints[key])
+            tableConstraints[key] = {};
         const columnNames = columns.split(',').map((column) => column.trim());
         columnNames.forEach((columnName) => {
-            if (!acc[key][columnName])
-                acc[key][columnName] = {};
+            if (!tableConstraints[key][columnName])
+                tableConstraints[key][columnName] = { checks: [] };
             if (constraint_type === 'PRIMARY KEY') {
-                acc[key][columnName].pk = true;
+                tableConstraints[key][columnName].pk = true;
             }
-            if (constraint_type === 'UNIQUE' && !acc[key][columnName].pk) {
-                acc[key][columnName].unique = true;
+            if (constraint_type === 'UNIQUE' && !tableConstraints[key][columnName].pk) {
+                tableConstraints[key][columnName].unique = true;
             }
         });
-        return acc;
-    }, {});
+    });
+    const checkListSql = `
+    SELECT
+      OBJECT_SCHEMA_NAME(cc.parent_object_id) AS table_schema,
+      OBJECT_NAME(cc.parent_object_id) AS table_name,
+      c.name AS column_name,
+      cc.name AS check_name,
+      cc.definition AS check_expression
+    FROM
+      sys.check_constraints cc
+    LEFT JOIN
+      sys.columns c ON cc.parent_object_id = c.object_id AND cc.parent_column_id = c.column_id
+    WHERE 1 = 1
+      ${(0, parseSchema_1.buildSchemaQuery)('OBJECT_SCHEMA_NAME(cc.parent_object_id)', schemas)}
+  `;
+    const checkListResult = await client.query(checkListSql);
+    const checks = {};
+    checkListResult.recordset.forEach((row) => {
+        const { table_schema, table_name, column_name, check_name, check_expression, } = row;
+        const key = `${table_schema}.${table_name}`;
+        if (column_name) {
+            if (!tableConstraints[key])
+                tableConstraints[key] = {};
+            if (!tableConstraints[key][column_name])
+                tableConstraints[key][column_name] = { checks: [] };
+            // The check definition has the form: `(expr)`
+            // The expression starts at 1 and ends at -1
+            tableConstraints[key][column_name].checks.push({ name: check_name, expression: check_expression.slice(1, -1) });
+            return;
+        }
+        if (!checks[key])
+            checks[key] = [];
+        // The check definition has the form: `(expr)`
+        // The expression starts at 1 and ends at -1
+        checks[key].push({ name: check_name, expression: check_expression.slice(1, -1) });
+    });
     return {
         indexes,
         tableConstraints,
+        checks,
     };
 };
 const fetchSchemaJson = async (connection) => {
     const { connectionString, schemas } = (0, parseSchema_1.parseConnectionString)(connection, 'odbc');
     const client = await getValidatedClient(connectionString);
-    const tablesFieldsAndEnumsRes = generateTablesFieldsAndEnums(client, schemas);
-    const indexesRes = generateIndexes(client, schemas);
+    const tablesRes = generateTablesFields(client, schemas);
+    const indexesAndConstraintsRes = generateIndexesAndConstraints(client, schemas);
     const refsRes = generateRefs(client, schemas);
     const res = await Promise.all([
-        tablesFieldsAndEnumsRes,
-        indexesRes,
+        tablesRes,
+        indexesAndConstraintsRes,
         refsRes,
     ]);
-    client.close();
-    const { tables, fields, enums } = res[0];
-    const { indexes, tableConstraints } = res[1];
+    const { tables, fields } = res[0];
+    const { indexes, tableConstraints, checks } = res[1];
     const refs = res[2];
     return {
         tables,
         fields,
-        enums,
+        // MSSQL doesn't support the notion of enums
+        enums: [],
         refs,
         indexes,
         tableConstraints,
+        checks,
     };
 };
 exports.fetchSchemaJson = fetchSchemaJson;

package/dist/connectors/mysqlConnector.js

@@ -164,7 +164,7 @@ async function generateEnums(client, schemaName) {
     return enumList;
 }
 /**
- * Mysql is automatically create index for primary keys, foreign keys, unique constraint. -> Ignore
+ * Mysql automatically creates index for primary keys, foreign keys, unique constraint. -> Ignore
  */
 async function generateIndexes(client, schemaName) {
     const query = `
@@ -251,8 +251,8 @@ async function generatePrimaryAndUniqueConstraint(client, schemaName) {
     const queryResponse = await client.query(query, [schemaName]);
     const rows = queryResponse[0];
     const inlineConstraintList = rows.filter((constraint) => constraint.columnCount === 1);
-    const outOfConstraintList = rows.filter((constraint) => constraint.columnCount > 1);
-    const compositeTableConstraintMap = outOfConstraintList.reduce((acc, row) => {
+    const outOfLineConstraintList = rows.filter((constraint) => constraint.columnCount > 1);
+    const compositeTableConstraintMap = outOfLineConstraintList.reduce((acc, row) => {
         const { tableName, constraintName, columnNames, constraintType, } = row;
         const key = tableName;
         if (!acc[key]) {
@@ -288,7 +288,7 @@ async function generatePrimaryAndUniqueConstraint(client, schemaName) {
         const columnList = columnNames.split(',');
         columnList.forEach((columnName) => {
             if (!acc[key][columnName]) {
-                acc[key][columnName] = {};
+                acc[key][columnName] = { checks: [] };
             }
             if (constraintType === 'PRIMARY KEY') {
                 acc[key][columnName].pk = true;
@@ -299,7 +299,54 @@ async function generatePrimaryAndUniqueConstraint(client, schemaName) {
         });
         return acc;
     }, {});
-    return { compositeConstraintMap, constraintMap };
+    return { compositeConstraintMap, primaryAndUniqueConstraintMap: constraintMap };
+}
+function extractColumnsFromCheckConstraint(checkClause) {
+    return [...checkClause.matchAll(/`(?:``|[^`])*`/g)].map((col) => col.toString().slice(1, -1));
+}
+async function generateCheckConstraints(client, schemaName) {
+    const query = `
+    select
+      cc.constraint_name as constraintName,
+      tc.table_name as tableName,
+      cc.check_clause as checkClause
+    from information_schema.check_constraints cc
+    join information_schema.table_constraints tc
+      on cc.constraint_name = tc.constraint_name
+    where cc.constraint_schema = ?
+  `;
+    const queryResponse = await client.query(query, [schemaName]);
+    const rows = queryResponse[0];
+    const checks = {};
+    const tableConstraints = {};
+    rows.forEach((row) => {
+        const { constraintName, tableName, checkClause, } = row;
+        const key = tableName;
+        const cols = extractColumnsFromCheckConstraint(checkClause);
+        if (cols.length === 1) {
+            const col = cols[0];
+            if (!tableConstraints[key])
+                tableConstraints[key] = {};
+            if (!tableConstraints[key][col])
+                tableConstraints[key][col] = { checks: [] };
+            tableConstraints[key][col].checks.push({
+                name: constraintName,
+                // The check definition has the form: `(expr)`
+                // The expression starts at 1 and ends at -1
+                expression: checkClause.slice(1, -1),
+            });
+            return;
+        }
+        if (!checks[key])
+            checks[key] = [];
+        checks[key].push({
+            name: constraintName,
+            // The check definition has the form: `(expr)`
+            // The expression starts at 1 and ends at -1
+            expression: checkClause.slice(1, -1),
+        });
+    });
+    return { checks, tableConstraints };
 }
 async function generateForeignKeys(client, schemaName) {
     const query = `
@@ -375,17 +422,29 @@ async function fetchSchemaJson(connection) {
         generateIndexes(client, schemaName),
         generatePrimaryAndUniqueConstraint(client, schemaName),
         generateForeignKeys(client, schemaName),
+        generateCheckConstraints(client, schemaName),
     ]);
     client.end();
-    const [{ tableList, fieldMap }, enumList, rawIndexMap, { constraintMap, compositeConstraintMap }, foreignKeyList,] = result;
+    const [{ tableList, fieldMap }, enumList, rawIndexMap, { primaryAndUniqueConstraintMap, compositeConstraintMap }, foreignKeyList, { checks: tableCheckConstraintMap, tableConstraints: columnCheckConstraintMap },] = result;
     // combine normal index and composite key
     const indexMap = combineIndexAndCompositeConstraint(rawIndexMap, compositeConstraintMap);
+    const tableConstraints = { ...primaryAndUniqueConstraintMap };
+    Object.keys(columnCheckConstraintMap).forEach((tableName) => {
+        if (!tableConstraints[tableName])
+            tableConstraints[tableName] = {};
+        Object.keys(columnCheckConstraintMap[tableName]).forEach((colName) => {
+            if (!tableConstraints[tableName][colName])
+                tableConstraints[tableName][colName] = { checks: [] };
+            tableConstraints[tableName][colName].checks.push(...columnCheckConstraintMap[tableName][colName].checks);
+        });
+    });
     return {
         tables: tableList,
         fields: fieldMap,
         refs: foreignKeyList,
         enums: enumList,
         indexes: indexMap,
-        tableConstraints: constraintMap,
+        tableConstraints,
+        checks: tableCheckConstraintMap,
     };
 }

package/dist/connectors/postgresConnector.d.ts

@@ -1,3 +1,3 @@
 import { DatabaseSchema } from './types';
 declare const fetchSchemaJson: (connection: string) => Promise<DatabaseSchema>;
-export { fetchSchemaJson };
+export { fetchSchemaJson, };

package/dist/connectors/postgresConnector.js

@@ -241,7 +241,7 @@ const generateRawRefs = async (client, schemas) => {
     });
     return refs;
 };
-const generateIndexes = async (client, schemas) => {
+const generateIndexesAndConstraints = async (client, schemas) => {
     const indexListSql = `
     WITH user_tables AS (
       SELECT
@@ -288,8 +288,8 @@ const generateIndexes = async (client, schemas) => {
       ii.is_unique,
       ii.is_primary,
       ii.index_type,
-      ii.columns,
-      ii.expressions,
+      ii.columns AS index_columns,
+      ii.expressions AS index_expressions,
       ii.constraint_type  -- Retained constraint type here
     FROM
       user_tables ut
@@ -304,29 +304,29 @@ const generateIndexes = async (client, schemas) => {
     ;
   `;
     const indexListResult = await client.query(indexListSql);
-    const { outOfLineConstraints, inlineConstraints } = indexListResult.rows.reduce((acc, row) => {
-        const { constraint_type, columns } = row;
-        if (columns === 'null' || columns.trim() === '')
+    const { outOfLineIndexes, inlineIndexes } = indexListResult.rows.reduce((acc, row) => {
+        const { constraint_type, index_columns } = row;
+        if (index_columns === 'null' || index_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);
+        const isSingleColumn = index_columns.split(',').length === 1;
+        const isInlineIndex = isSingleColumn && (constraint_type === 'PRIMARY KEY' || constraint_type === 'UNIQUE');
+        if (isInlineIndex) {
+            acc.inlineIndexes.push(row);
         }
         else {
-            acc.outOfLineConstraints.push(row);
+            acc.outOfLineIndexes.push(row);
         }
         return acc;
-    }, { outOfLineConstraints: [], inlineConstraints: [] });
-    const indexes = outOfLineConstraints.reduce((acc, indexRow) => {
-        const { table_schema, table_name, index_name, index_type, columns, expressions, } = indexRow;
-        const indexColumns = columns.split(',').map((column) => {
+    }, { outOfLineIndexes: [], inlineIndexes: [] });
+    const indexes = outOfLineIndexes.reduce((acc, indexRow) => {
+        const { table_schema, table_name, index_name, index_type, index_columns, index_expressions, } = indexRow;
+        const indexColumns = index_columns.split(',').map((column) => {
             return {
                 type: 'column',
                 value: column.trim(),
             };
         });
-        const indexExpressions = expressions ? expressions.split(',').map((expression) => {
+        const indexExpressions = index_expressions ? index_expressions.split(',').map((expression) => {
             return {
                 type: 'expression',
                 value: expression,
@@ -349,27 +349,94 @@ const generateIndexes = async (client, schemas) => {
         }
         return acc;
     }, {});
-    const tableConstraints = inlineConstraints.reduce((acc, row) => {
-        const { table_schema, table_name, columns, constraint_type, } = row;
+    const tableConstraints = {};
+    inlineIndexes.forEach((row) => {
+        const { table_schema, table_name, index_columns, constraint_type, } = row;
         const key = `${table_schema}.${table_name}`;
-        if (!acc[key])
-            acc[key] = {};
-        const columnNames = columns.split(',').map((column) => column.trim());
+        if (!tableConstraints[key])
+            tableConstraints[key] = {};
+        const columnNames = index_columns.split(',').map((column) => column.trim());
         columnNames.forEach((columnName) => {
-            if (!acc[key][columnName])
-                acc[key][columnName] = {};
+            if (!tableConstraints[key][columnName])
+                tableConstraints[key][columnName] = { checks: [] };
             if (constraint_type === 'PRIMARY KEY') {
-                acc[key][columnName].pk = true;
+                tableConstraints[key][columnName].pk = true;
             }
-            if (constraint_type === 'UNIQUE' && !acc[key][columnName].pk) {
-                acc[key][columnName].unique = true;
+            if (constraint_type === 'UNIQUE' && !tableConstraints[key][columnName].pk) {
+                tableConstraints[key][columnName].unique = true;
             }
         });
-        return acc;
     }, {});
+    const checkListSql = `
+    SELECT
+      n.nspname AS table_schema,
+      c.relname AS table_name,
+      MAX(a.attname) AS column_name,
+      con.conname AS check_name,
+      pg_get_constraintdef(con.oid) AS check_definition,
+      CASE
+        WHEN COUNT(*) = 1 THEN TRUE
+        ELSE FALSE
+      END AS is_column_constraint 
+    FROM
+      pg_catalog.pg_constraint AS con
+    JOIN
+      pg_catalog.pg_class AS c
+      ON con.conrelid = c.oid
+    LEFT JOIN
+      pg_catalog.pg_namespace AS n
+      ON c.relnamespace = n.oid
+    LEFT JOIN
+      pg_catalog.pg_attribute AS a
+      ON a.attrelid = c.oid AND a.attnum = ANY(con.conkey)
+    WHERE con.contype = 'c' -- 'c' for CHECK constraints
+    ${(0, parseSchema_1.buildSchemaQuery)('n.nspname', schemas)}
+    GROUP BY
+      con.conname,
+      n.nspname,
+      c.relname,
+      con.oid
+  `;
+    const checkListResult = await client.query(checkListSql);
+    const checks = {};
+    checkListResult.rows.forEach((row) => {
+        const { table_schema, table_name, check_name, check_definition, column_name, is_column_constraint, } = row;
+        if (typeof table_schema !== 'string' || typeof table_name !== 'string' || typeof check_definition !== 'string') {
+            return;
+        }
+        if (!check_definition.match(/CHECK \(\(.*\)\)/)) {
+            return;
+        }
+        if (is_column_constraint && typeof column_name !== 'string') {
+            return;
+        }
+        const key = `${table_schema}.${table_name}`;
+        if (is_column_constraint) {
+            if (!tableConstraints[key])
+                tableConstraints[key] = {};
+            if (!tableConstraints[key][column_name])
+                tableConstraints[key][column_name] = { checks: [] };
+            tableConstraints[key][column_name].checks.push({
+                name: check_name || undefined,
+                // The check definition has the form: `CHECK ((expr))`
+                // The expression starts at 8 and ends at -2
+                expression: check_definition.slice(8, -2),
+            });
+            return;
+        }
+        if (!checks[key])
+            checks[key] = [];
+        checks[key].push({
+            name: check_name || undefined,
+            // The check definition has the form: `CHECK ((expr))`
+            // The expression starts at 8 and ends at -2
+            expression: check_definition.slice(8, -2),
+        });
+    });
     return {
         indexes,
         tableConstraints,
+        checks,
     };
 };
 const generateRawEnums = async (client, schemas) => {
@@ -414,7 +481,7 @@ const fetchSchemaJson = async (connection) => {
     const { connectionString, schemas } = (0, parseSchema_1.parseConnectionString)(connection, 'jdbc');
     const client = await getValidatedClient(connectionString);
     const tablesAndFieldsRes = generateTablesAndFields(client, schemas);
-    const indexesRes = generateIndexes(client, schemas);
+    const indexesRes = generateIndexesAndConstraints(client, schemas);
     const refsRes = generateRawRefs(client, schemas);
     const enumsRes = generateRawEnums(client, schemas);
     const res = await Promise.all([
@@ -425,7 +492,7 @@ const fetchSchemaJson = async (connection) => {
     ]);
     client.end();
     const { tables, fields } = res[0];
-    const { indexes, tableConstraints } = res[1];
+    const { indexes, tableConstraints, checks } = res[1];
     const refs = res[2];
     const enums = res[3];
     return {
@@ -435,6 +502,7 @@ const fetchSchemaJson = async (connection) => {
         enums,
         indexes,
         tableConstraints,
+        checks,
     };
 };
 exports.fetchSchemaJson = fetchSchemaJson;