@dbml/connector 5.4.0 → 5.5.0

package/__tests__/connector.test.ts

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
-import { scanDirNames } from '../jestHelpers.ts';
-import { connector } from '../src/index.ts';
+import { scanDirNames } from './testHelpers';
+import { connector } from '../src/index';
 
 const sortKeys = (obj: any): any => {
   if (Array.isArray(obj)) {

package/{jestHelpers.ts → __tests__/testHelpers.ts}

@@ -1,13 +1,9 @@
 import fs from 'fs';
 import path from 'path';
 
-const scanDirNames = (dirname: string, subpath: string): string[] => {
+export function scanDirNames (dirname: string, subpath: string): string[] {
   const dirPath = path.join(dirname, subpath);
   const sanitizedDirPath = path.normalize(dirPath);
   const dirs = fs.readdirSync(sanitizedDirPath);
   return dirs;
-};
-
-export {
-  scanDirNames,
-};
+}

package/dist/connectors/mssql/index.js

@@ -456,26 +456,31 @@ const generateIndexesAndConstraints = async (client, schemas) => {
 const fetchSchemaJson = async (connection) => {
     const { connectionString, schemas } = (0, parseSchema_1.parseConnectionString)(connection, 'odbc');
     const client = await getValidatedClient(connectionString);
-    const tablesRes = generateTablesFields(client, schemas);
-    const indexesAndConstraintsRes = generateIndexesAndConstraints(client, schemas);
-    const refsRes = generateRefs(client, schemas);
-    const res = await Promise.all([
-        tablesRes,
-        indexesAndConstraintsRes,
-        refsRes,
-    ]);
-    const { tables, fields } = res[0];
-    const { indexes, tableConstraints, checks } = res[1];
-    const refs = res[2];
-    return {
-        tables,
-        fields,
-        // MSSQL doesn't support the notion of enums
-        enums: [],
-        refs,
-        indexes,
-        tableConstraints,
-        checks,
-    };
+    try {
+        const tablesRes = generateTablesFields(client, schemas);
+        const indexesAndConstraintsRes = generateIndexesAndConstraints(client, schemas);
+        const refsRes = generateRefs(client, schemas);
+        const res = await Promise.all([
+            tablesRes,
+            indexesAndConstraintsRes,
+            refsRes,
+        ]);
+        const { tables, fields } = res[0];
+        const { indexes, tableConstraints, checks } = res[1];
+        const refs = res[2];
+        return {
+            tables,
+            fields,
+            // MSSQL doesn't support the notion of enums
+            enums: [],
+            refs,
+            indexes,
+            tableConstraints,
+            checks,
+        };
+    }
+    finally {
+        await client.close();
+    }
 };
 exports.fetchSchemaJson = fetchSchemaJson;

package/dist/connectors/mysql/index.js

@@ -416,35 +416,39 @@ async function fetchSchemaJson(connection) {
     if (!schemaName) {
         throw new Error('Cannot get schema name from the connection');
     }
-    const result = await Promise.all([
-        generateTablesAndFields(client, schemaName),
-        generateEnums(client, schemaName),
-        generateIndexes(client, schemaName),
-        generatePrimaryAndUniqueConstraint(client, schemaName),
-        generateForeignKeys(client, schemaName),
-        generateCheckConstraints(client, schemaName),
-    ]);
-    client.end();
-    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);
+    try {
+        const result = await Promise.all([
+            generateTablesAndFields(client, schemaName),
+            generateEnums(client, schemaName),
+            generateIndexes(client, schemaName),
+            generatePrimaryAndUniqueConstraint(client, schemaName),
+            generateForeignKeys(client, schemaName),
+            generateCheckConstraints(client, schemaName),
+        ]);
+        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,
-        checks: tableCheckConstraintMap,
-    };
+        return {
+            tables: tableList,
+            fields: fieldMap,
+            refs: foreignKeyList,
+            enums: enumList,
+            indexes: indexMap,
+            tableConstraints,
+            checks: tableCheckConstraintMap,
+        };
+    }
+    finally {
+        await client.end();
+    }
 }

package/dist/connectors/postgres/index.js

@@ -485,29 +485,33 @@ const generateRawEnums = async (client, schemas) => {
 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 = generateIndexesAndConstraints(client, schemas);
-    const refsRes = generateRawRefs(client, schemas);
-    const enumsRes = generateRawEnums(client, schemas);
-    const res = await Promise.all([
-        tablesAndFieldsRes,
-        indexesRes,
-        refsRes,
-        enumsRes,
-    ]);
-    client.end();
-    const { tables, fields } = res[0];
-    const { indexes, tableConstraints, checks } = res[1];
-    const refs = res[2];
-    const enums = res[3];
-    return {
-        tables,
-        fields,
-        refs,
-        enums,
-        indexes,
-        tableConstraints,
-        checks,
-    };
+    try {
+        const tablesAndFieldsRes = generateTablesAndFields(client, schemas);
+        const indexesRes = generateIndexesAndConstraints(client, schemas);
+        const refsRes = generateRawRefs(client, schemas);
+        const enumsRes = generateRawEnums(client, schemas);
+        const res = await Promise.all([
+            tablesAndFieldsRes,
+            indexesRes,
+            refsRes,
+            enumsRes,
+        ]);
+        const { tables, fields } = res[0];
+        const { indexes, tableConstraints, checks } = res[1];
+        const refs = res[2];
+        const enums = res[3];
+        return {
+            tables,
+            fields,
+            refs,
+            enums,
+            indexes,
+            tableConstraints,
+            checks,
+        };
+    }
+    finally {
+        await client.end();
+    }
 };
 exports.fetchSchemaJson = fetchSchemaJson;

package/eslint.config.ts

@@ -19,9 +19,9 @@ export default defineConfig(
         'node_modules/*',
         'dist/*',
         'eslint.config.ts',
-        'jestHelpers.ts',
         'jest.config.ts',
         '**/*.test.ts',
+        '__tests__/**/*',
       ],
     },
     {

package/jest.config.ts

@@ -1,4 +1,7 @@
-module.exports = {
+import { type Config } from 'jest';
+
+const config: Config = {
+  testMatch: ["**/?(*.)+(spec|test).?([mc])[jt]s?(x)"],
   preset: 'ts-jest',
   testEnvironment: 'node',
   transform: {
@@ -7,4 +10,9 @@ module.exports = {
   moduleNameMapper: {
     '\\.(css|less|scss)$': 'identity-obj-proxy',
   },
+  collectCoverage: true,
+  coverageReporters: ['json', 'json-summary', 'html', 'text'],
+  coverageDirectory: 'coverage',
 };
+
+export default config;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/connector",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "This package was created to fetch the schema JSON from many kind of databases.",
   "author": "huy.phung.sw@gmail.com",
   "license": "MIT",
@@ -36,7 +36,8 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "test": "jest",
+    "test": "jest --coverage=false",
+    "coverage": "jest --coverage",
     "lint": "eslint .",
     "lint:fix": "eslint --fix ."
   },
@@ -55,5 +56,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "e7837a6418602e2b9d5a350335b669155d5c7ad4"
+  "gitHead": "dc9d32e973037784935ec6d92d22e751945bb194"
 }

package/src/connectors/mssql/index.ts

@@ -553,30 +553,34 @@ const fetchSchemaJson = async (connection: string): Promise<DatabaseSchema> => {
   const { connectionString, schemas } = parseConnectionString(connection, 'odbc');
   const client = await getValidatedClient(connectionString);
 
-  const tablesRes = generateTablesFields(client, schemas);
-  const indexesAndConstraintsRes = generateIndexesAndConstraints(client, schemas);
-  const refsRes = generateRefs(client, schemas);
-
-  const res = await Promise.all([
-    tablesRes,
-    indexesAndConstraintsRes,
-    refsRes,
-  ]);
-
-  const { tables, fields } = res[0];
-  const { indexes, tableConstraints, checks } = res[1];
-  const refs = res[2];
-
-  return {
-    tables,
-    fields,
-    // MSSQL doesn't support the notion of enums
-    enums: [],
-    refs,
-    indexes,
-    tableConstraints,
-    checks,
-  };
+  try {
+    const tablesRes = generateTablesFields(client, schemas);
+    const indexesAndConstraintsRes = generateIndexesAndConstraints(client, schemas);
+    const refsRes = generateRefs(client, schemas);
+
+    const res = await Promise.all([
+      tablesRes,
+      indexesAndConstraintsRes,
+      refsRes,
+    ]);
+
+    const { tables, fields } = res[0];
+    const { indexes, tableConstraints, checks } = res[1];
+    const refs = res[2];
+
+    return {
+      tables,
+      fields,
+      // MSSQL doesn't support the notion of enums
+      enums: [],
+      refs,
+      indexes,
+      tableConstraints,
+      checks,
+    };
+  } finally {
+    await client.close();
+  }
 };
 
 export {

package/src/connectors/mysql/index.ts

@@ -531,46 +531,49 @@ async function fetchSchemaJson (connection: string): Promise<DatabaseSchema> {
     throw new Error('Cannot get schema name from the connection');
   }
 
-  const result = await Promise.all([
-    generateTablesAndFields(client, schemaName),
-    generateEnums(client, schemaName),
-    generateIndexes(client, schemaName),
-    generatePrimaryAndUniqueConstraint(client, schemaName),
-    generateForeignKeys(client, schemaName),
-    generateCheckConstraints(client, schemaName),
-  ]);
-  client.end();
-
-  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: TableConstraintsDictionary = { ...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);
+  try {
+    const result = await Promise.all([
+      generateTablesAndFields(client, schemaName),
+      generateEnums(client, schemaName),
+      generateIndexes(client, schemaName),
+      generatePrimaryAndUniqueConstraint(client, schemaName),
+      generateForeignKeys(client, schemaName),
+      generateCheckConstraints(client, schemaName),
+    ]);
+
+    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: TableConstraintsDictionary = { ...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,
-    checks: tableCheckConstraintMap,
-  };
+    return {
+      tables: tableList,
+      fields: fieldMap,
+      refs: foreignKeyList,
+      enums: enumList,
+      indexes: indexMap,
+      tableConstraints,
+      checks: tableCheckConstraintMap,
+    };
+  } finally {
+    await client.end();
+  }
 }
 
 export {

package/src/connectors/postgres/index.ts

@@ -576,33 +576,36 @@ const fetchSchemaJson = async (connection: string): Promise<DatabaseSchema> => {
   const { connectionString, schemas } = parseConnectionString(connection, 'jdbc');
   const client = await getValidatedClient(connectionString);
 
-  const tablesAndFieldsRes = generateTablesAndFields(client, schemas);
-  const indexesRes = generateIndexesAndConstraints(client, schemas);
-  const refsRes = generateRawRefs(client, schemas);
-  const enumsRes = generateRawEnums(client, schemas);
-
-  const res = await Promise.all([
-    tablesAndFieldsRes,
-    indexesRes,
-    refsRes,
-    enumsRes,
-  ]);
-  client.end();
-
-  const { tables, fields } = res[0];
-  const { indexes, tableConstraints, checks } = res[1];
-  const refs = res[2];
-  const enums = res[3];
+  try {
+    const tablesAndFieldsRes = generateTablesAndFields(client, schemas);
+    const indexesRes = generateIndexesAndConstraints(client, schemas);
+    const refsRes = generateRawRefs(client, schemas);
+    const enumsRes = generateRawEnums(client, schemas);
+
+    const res = await Promise.all([
+      tablesAndFieldsRes,
+      indexesRes,
+      refsRes,
+      enumsRes,
+    ]);
+
+    const { tables, fields } = res[0];
+    const { indexes, tableConstraints, checks } = res[1];
+    const refs = res[2];
+    const enums = res[3];
 
-  return {
-    tables,
-    fields,
-    refs,
-    enums,
-    indexes,
-    tableConstraints,
-    checks,
-  };
+    return {
+      tables,
+      fields,
+      refs,
+      enums,
+      indexes,
+      tableConstraints,
+      checks,
+    };
+  } finally {
+    await client.end();
+  }
 };
 
 export {