@dbml/connector 3.10.1 → 3.10.2

package/dist/connectors/mssqlConnector.js

@@ -88,7 +88,7 @@ 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) => {
+const getEnumValues = (definition, constraint_name) => {
     // Use the example below to understand the regex:
     // ([quantity]>(0))
     // ([unit_price]>(0))
@@ -102,15 +102,48 @@ const getEnumValues = (definition) => {
     // ([date_of_birth]<=dateadd(year,(-13),getdate()))
     // ([email] like '%_@_%._%')
     if (!definition)
-        return null;
+        return [];
     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 [];
+    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;
+        let mergedColumns = [key];
+        const values = colMap[key];
+        Object.keys(colMap).forEach((innerKey) => {
+            if (key !== innerKey && arraysEqual(values, colMap[innerKey])) {
+                mergedColumns.push(innerKey);
+                processedKeys.add(innerKey);
+            }
+        });
+        const enumValues = values.map((value) => ({ name: value }));
+        result.push({ columns: mergedColumns, enumValues, constraint_name: `${constraint_name}_${mergedColumns.join('_')}` });
+        processedKeys.add(key);
     });
-    return enumValues;
+    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;
@@ -129,6 +162,7 @@ const generateField = (row) => {
     };
 };
 const generateTablesFieldsAndEnums = async (client, schemas) => {
+    const checkConstraintDefinitionDedup = {};
     const fields = {};
     const enums = [];
     const tablesAndFieldsSql = `
@@ -239,22 +273,29 @@ const generateTablesFieldsAndEnums = async (client, schemas) => {
                 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[key])
             fields[key] = [];
         const field = generateField(row);
-        if (enumValues) {
-            field.type = {
-                type_name: check_constraint_name,
-                schemaName: table_schema,
-            };
+        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;
@@ -301,6 +342,14 @@ const generateRefs = async (client, schemas) => {
       t.name;
   `;
     const refsQueryResult = await client.query(refsListSql);
+    const endpointsEqual = (ep1, ep2) => {
+        if (ep1.length !== ep2.length)
+            return false;
+        return ep1.every((endpoint, index) => endpoint.tableName === ep2[index].tableName &&
+            endpoint.schemaName === ep2[index].schemaName &&
+            endpoint.fieldNames.length === ep2[index].fieldNames.length &&
+            endpoint.fieldNames.every((field, fieldIndex) => field === ep2[index].fieldNames[fieldIndex]));
+    };
     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 = {
@@ -315,12 +364,16 @@ const generateRefs = async (client, schemas) => {
             fieldNames: foreign_column_names.split(','),
             relation: '1',
         };
-        refs.push({
+        const newRef = {
             name: fk_constraint_name,
             endpoints: [ep1, ep2],
             onDelete: on_delete === 'NO_ACTION' ? null : on_delete,
             onUpdate: on_update === 'NO_ACTION' ? null : on_update,
-        });
+        };
+        const isDuplicate = refs.some(ref => endpointsEqual(ref.endpoints, newRef.endpoints));
+        if (!isDuplicate) {
+            refs.push(newRef);
+        }
     });
     return refs;
 };

package/dist/connectors/types.d.ts

@@ -87,4 +87,9 @@ interface BigQueryCredentials {
     };
     datasets: string[];
 }
-export { NoteInfo, TypeInfo, DefaultType, DefaultInfo, Field, Table, FieldsDictionary, TableConstraint, TableConstraintsDictionary, RefEndpoint, Ref, EnumValue, Enum, IndexColumn, Index, IndexesDictionary, DatabaseSchema, BigQueryCredentials, };
+interface EnumValuesDict {
+    columns: string[];
+    enumValues: EnumValue[];
+    constraint_name: string;
+}
+export { NoteInfo, TypeInfo, DefaultType, DefaultInfo, Field, Table, FieldsDictionary, TableConstraint, TableConstraintsDictionary, RefEndpoint, Ref, EnumValue, Enum, IndexColumn, Index, IndexesDictionary, DatabaseSchema, BigQueryCredentials, EnumValuesDict, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/connector",
-  "version": "3.10.1",
+  "version": "3.10.2",
   "description": "This package was created to fetch the schema JSON from many kind of databases.",
   "author": "huy.phung.sw@gmail.com",
   "license": "MIT",
@@ -40,5 +40,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "dd0f5c05a941782a95d2f45ebbf5b3ddd78bf2b3"
+  "gitHead": "59a06de19f675bf9af31bdb9801d8e022ef87529"
 }

package/src/connectors/mssqlConnector.ts

@@ -14,6 +14,7 @@ import {
   RefEndpoint,
   Table,
   TableConstraintsDictionary,
+  EnumValuesDict,
 } from './types';
 
 // https://learn.microsoft.com/en-us/sql/t-sql/data-types/date-and-time-types?view=sql-server-ver15
@@ -111,7 +112,7 @@ const getDbdefault = (data_type: string, column_default: string, default_type: D
   };
 };
 
-const getEnumValues = (definition: string): EnumValue[] | null => {
+const getEnumValues = (definition: string, constraint_name: string): EnumValuesDict[] => {
   // Use the example below to understand the regex:
   // ([quantity]>(0))
   // ([unit_price]>(0))
@@ -124,15 +125,51 @@ const getEnumValues = (definition: string): EnumValue[] | null => {
   // ([gender]='Other' OR [gender]='Female' OR [gender]='Male')
   // ([date_of_birth]<=dateadd(year,(-13),getdate()))
   // ([email] like '%_@_%._%')
-  if (!definition) return null;
+  if (!definition) return [];
   const values = definition.match(/\[([^\]]+)\]='([^']+)'/g); // Extracting the enum values when the definition contains ]='
-  if (!values) return null;
+  if (!values) return [];
+
+  const colMap: { [key: string]: string[] } = {};
+  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: string[], b: string[]): boolean => {
+    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: EnumValuesDict[] = [];
+  const processedKeys = new Set<string>();
+
+  Object.keys(colMap).forEach((key) => {
+    if (processedKeys.has(key)) return;
+
+    let mergedColumns = [key];
+    const values = colMap[key];
 
-  const enumValues = values.map((value) => {
-    const enumValue = value.split("]='")[1];
-    return { name: enumValue.slice(0, -1) };
+    Object.keys(colMap).forEach((innerKey) => {
+      if (key !== innerKey && arraysEqual(values, colMap[innerKey])) {
+        mergedColumns.push(innerKey);
+        processedKeys.add(innerKey);
+      }
+    });
+    const enumValues = values.map((value) => ({ name: value }));
+    result.push({ columns: mergedColumns, enumValues, constraint_name: `${constraint_name}_${mergedColumns.join('_')}` });
+    processedKeys.add(key);
   });
-  return enumValues;
+
+  return result;
 };
 
 const generateField = (row: Record<string, any>): Field => {
@@ -171,6 +208,8 @@ const generateTablesFieldsAndEnums = async (client: sql.ConnectionPool, schemas:
   fields: FieldsDictionary,
   enums: Enum[],
 }> => {
+  const checkConstraintDefinitionDedup: { [key: string]: EnumValuesDict[] } = {};
+
   const fields: FieldsDictionary = {};
   const enums: Enum[] = [];
   const tablesAndFieldsSql = `
@@ -290,23 +329,32 @@ const generateTablesFieldsAndEnums = async (client: sql.ConnectionPool, schemas:
       };
     }
 
-    const enumValues = getEnumValues(check_constraint_definition);
-    if (enumValues) {
-      enums.push({
-        name: check_constraint_name,
-        schemaName: table_schema,
-        values: enumValues,
+    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 (!fields[key]) fields[key] = [];
-    const field = generateField(row);
-    if (enumValues) {
-      field.type = {
-        type_name: check_constraint_name,
-        schemaName: table_schema,
-      };
+    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;
@@ -357,6 +405,17 @@ const generateRefs = async (client: sql.ConnectionPool, schemas: string[]): Prom
   `;
 
   const refsQueryResult = await client.query(refsListSql);
+
+  const endpointsEqual = (ep1: RefEndpoint[], ep2: RefEndpoint[]): boolean => {
+    if (ep1.length !== ep2.length) return false;
+    return ep1.every((endpoint, index) => 
+      endpoint.tableName === ep2[index].tableName &&
+      endpoint.schemaName === ep2[index].schemaName &&
+      endpoint.fieldNames.length === ep2[index].fieldNames.length &&
+      endpoint.fieldNames.every((field, fieldIndex) => field === ep2[index].fieldNames[fieldIndex])
+    );
+  };
+
   refsQueryResult.recordset.forEach((refRow) => {
     const {
       table_schema,
@@ -384,12 +443,18 @@ const generateRefs = async (client: sql.ConnectionPool, schemas: string[]): Prom
       relation: '1',
     };
 
-    refs.push({
+    const newRef = {
       name: fk_constraint_name,
       endpoints: [ep1, ep2],
       onDelete: on_delete === 'NO_ACTION' ? null : on_delete,
       onUpdate: on_update === 'NO_ACTION' ? null : on_update,
-    });
+    };
+
+    const isDuplicate = refs.some(ref => endpointsEqual(ref.endpoints, newRef.endpoints));
+
+    if (!isDuplicate) {
+      refs.push(newRef);
+    }
   });
 
   return refs;

package/src/connectors/types.ts

@@ -1,3 +1,5 @@
+import { columns } from "mssql";
+
 interface NoteInfo {
   value: string;
 }
@@ -106,6 +108,59 @@ interface BigQueryCredentials {
   datasets: string[],
 }
 
+// Currently, we parse the check constraints as enum values in mssql.
+// However, one check constraint can have multiple set of enum values.
+// So, we need to store the enum values in a dictionary.
+// Examples:
+// CREATE TABLE AddressInfo (
+//   A1 UNIQUEIDENTIFIER NOT NULL,
+//   A2 UNIQUEIDENTIFIER NOT NULL,
+//   A3 UNIQUEIDENTIFIER NOT NULL,
+//   A4 UNIQUEIDENTIFIER NOT NULL,
+//   CONSTRAINT CK_Address_Valid CHECK (
+//       A1 IN ('1111', '2222', '333') AND
+//       A2 IN ('1111', '2222') AND
+//       A3 IN ('2222', '1111') AND
+//       A4 IN ('2222', '3333')
+//   )
+// );
+// GO
+// In the above example, we have a check constraint CK_Address_Valid2 with 4 columns: A1, A2, A3, A4.
+// Each column has a different set of enum values. So, we need to store the enum values in a dictionary.
+// In the above example, the enum values dictionary will look like this:
+// [
+//   {
+//     columns : ['A1'],
+//     enumValues: [
+//       { name: '1111' },
+//       { name: '2222' },
+//       { name: '333' }
+//     ],
+//     constraint_name: 'CK_Address_Valid_A1'
+//   },
+//   {
+//     columns : ['A2, A3'], => In this case, these two columns have the same set of enum values.
+//     enumValues: [
+//       { name: '1111' },
+//       { name: '2222' }
+//     ],
+//     constraint_name: 'CK_Address_Valid_A2_A3'
+//   },
+//   {
+//     columns : ['A4'],
+//     enumValues: [
+//       { name: '2222' },
+//       { name: '3333' }
+//     ],
+//     constraint_name: 'CK_Address_Valid_A4'
+//   }
+// ]
+interface EnumValuesDict {
+  columns: string[],
+  enumValues: EnumValue[],
+  constraint_name: string,
+}
+
 export {
   NoteInfo,
   TypeInfo,
@@ -125,4 +180,5 @@ export {
   IndexesDictionary,
   DatabaseSchema,
   BigQueryCredentials,
+  EnumValuesDict,
 };