@dbml/connector 3.7.4 → 3.8.1

package/dist/connectors/mssqlConnector.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchSchemaJson = void 0;
 /* eslint-disable camelcase */
 const mssql_1 = __importDefault(require("mssql"));
+const parseSchema_1 = require("../utils/parseSchema");
 const MSSQL_DATE_TYPES = [
     'date',
     'datetime',
@@ -101,79 +102,103 @@ const generateField = (row) => {
         note: column_comment ? { value: column_comment } : { value: '' },
     };
 };
-const generateTablesFieldsAndEnums = async (client) => {
+const generateTablesFieldsAndEnums = async (client, schemas) => {
     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,
+      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
+    ),
+    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 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
+              WHEN check_constraint_definition IS NOT NULL THEN 1
+              ELSE 2
+            END,
+            check_constraint_name
+        ) AS rn
+      FROM
+        constraints_with_nulls
     )
     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
+      table_schema,
+      table_name,
+      column_name,
+      data_type,
+      character_maximum_length,
+      numeric_precision,
+      numeric_scale,
+      identity_increment,
+      is_nullable,
+      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
-        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
+    WHERE
+      rn = 1
+      ${(0, parseSchema_1.buildSchemaQuery)('table_schema', schemas, 'WHERE')}
     ORDER BY
-        tf.table_schema,
-        tf.table_name,
-        tf.column_name;
+      table_schema,
+      table_name,
+      column_name;
   `;
     const tablesAndFieldsResult = await client.query(tablesAndFieldsSql);
     const tables = tablesAndFieldsResult.recordset.reduce((acc, row) => {
@@ -212,7 +237,7 @@ const generateTablesFieldsAndEnums = async (client) => {
         enums,
     };
 };
-const generateRefs = async (client) => {
+const generateRefs = async (client, schemas) => {
     const refs = [];
     const refsListSql = `
     SELECT
@@ -242,6 +267,7 @@ const generateRefs = async (client) => {
     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')
+      ${(0, parseSchema_1.buildSchemaQuery)('s.name', schemas)}
     ORDER BY
       s.name,
       t.name;
@@ -270,7 +296,7 @@ const generateRefs = async (client) => {
     });
     return refs;
 };
-const generateIndexes = async (client) => {
+const generateIndexes = async (client, schemas) => {
     const indexListSql = `
     WITH user_tables AS (
       SELECT
@@ -288,6 +314,7 @@ const generateIndexes = async (client) => {
     ),
     index_info AS (
       SELECT
+        SCHEMA_NAME(t.schema_id) AS table_schema,  -- Add schema information
         OBJECT_NAME(i.object_id) AS table_name,
         i.name AS index_name,
         i.is_unique,
@@ -335,8 +362,10 @@ const generateIndexes = async (client) => {
       user_tables ut
     LEFT JOIN
       index_info ii ON ut.TABLE_NAME = ii.table_name
+      AND ut.TABLE_SCHEMA = ii.table_schema
     WHERE
       ii.columns IS NOT NULL
+      ${(0, parseSchema_1.buildSchemaQuery)('ut.TABLE_SCHEMA', schemas)}
     ORDER BY
       ut.TABLE_NAME,
       ii.constraint_type,
@@ -410,10 +439,11 @@ const generateIndexes = async (client) => {
     };
 };
 const fetchSchemaJson = async (connection) => {
-    const client = await getValidatedClient(connection);
-    const tablesFieldsAndEnumsRes = generateTablesFieldsAndEnums(client);
-    const indexesRes = generateIndexes(client);
-    const refsRes = generateRefs(client);
+    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 refsRes = generateRefs(client, schemas);
     const res = await Promise.all([
         tablesFieldsAndEnumsRes,
         indexesRes,

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchSchemaJson = void 0;
 /* eslint-disable camelcase */
 const pg_1 = require("pg");
+const parseSchema_1 = require("../utils/parseSchema");
 const getValidatedClient = async (connection) => {
     const client = new pg_1.Client(connection);
     try {
@@ -78,11 +79,11 @@ const generateField = (row) => {
         note: column_comment ? { value: column_comment } : { value: '' },
     };
 };
-const generateTablesAndFields = async (client) => {
+const generateTablesAndFields = async (client, schemas) => {
     const fields = {};
     const tablesAndFieldsSql = `
     WITH comments AS (
-      SELECT
+      SELECT DISTINCT ON (pc.relname, pn.nspname, pa.attname)
         pc.relname AS table_name,
         pn.nspname AS table_schema,
         pa.attname AS column_name,
@@ -112,6 +113,7 @@ const generateTablesAndFields = async (client) => {
       c.identity_increment,
       c.is_nullable,
       c.column_default,
+      c.ordinal_position,
       CASE
         WHEN c.column_default IS NULL THEN NULL
         WHEN c.column_default LIKE 'nextval(%' THEN 'increment'
@@ -120,8 +122,8 @@ const generateTablesAndFields = async (client) => {
         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
+      (SELECT description FROM comments WHERE table_name = t.table_name AND table_schema = t.table_schema AND column_name IS NULL LIMIT 1) 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 LIMIT 1) AS column_comment
     FROM
       information_schema.columns c
     JOIN
@@ -129,6 +131,7 @@ const generateTablesAndFields = async (client) => {
     WHERE
       t.table_type = 'BASE TABLE'
       AND t.table_schema NOT IN ('pg_catalog', 'information_schema')
+      ${(0, parseSchema_1.buildSchemaQuery)('t.table_schema', schemas)}
     ORDER BY
       t.table_schema,
       t.table_name,
@@ -157,7 +160,7 @@ const generateTablesAndFields = async (client) => {
         fields,
     };
 };
-const generateRawRefs = async (client) => {
+const generateRawRefs = async (client, schemas) => {
     const refs = [];
     const refsListSql = `
     SELECT
@@ -182,6 +185,7 @@ const generateRawRefs = async (client) => {
       AND tc.table_schema = rc.constraint_schema
     WHERE tc.constraint_type = 'FOREIGN KEY'
       AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')
+      ${(0, parseSchema_1.buildSchemaQuery)('tc.table_schema', schemas)}
     GROUP BY
       tc.table_schema,
       tc.table_name,
@@ -219,8 +223,7 @@ const generateRawRefs = async (client) => {
     });
     return refs;
 };
-const generateIndexes = async (client) => {
-    // const tableConstraints = {};
+const generateIndexes = async (client, schemas) => {
     const indexListSql = `
     WITH user_tables AS (
       SELECT
@@ -233,6 +236,7 @@ const generateIndexes = async (client) => {
     ),
     index_info AS (
       SELECT
+        t.relnamespace::regnamespace::text AS table_schema,
         t.relname AS table_name,
         i.relname AS index_name,
         ix.indisunique AS is_unique,
@@ -257,7 +261,7 @@ const generateIndexes = async (client) => {
         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
+        t.relnamespace, t.relname, i.relname, ix.indisunique, ix.indisprimary, am.amname, ix.indexprs, ix.indrelid
     )
     SELECT
       ut.tableschema AS table_schema,
@@ -268,12 +272,13 @@ const generateIndexes = async (client) => {
       ii.index_type,
       ii.columns,
       ii.expressions,
-      ii.constraint_type  -- Added constraint type
+      ii.constraint_type  -- Retained constraint type here
     FROM
       user_tables ut
     LEFT JOIN
-      index_info ii ON ut.tablename = ii.table_name
+      index_info ii ON ut.tableschema = ii.table_schema AND ut.tablename = ii.table_name
     WHERE ii.columns IS NOT NULL
+    ${(0, parseSchema_1.buildSchemaQuery)('ut.tableschema', schemas)}
     ORDER BY
       ut.tablename,
       ii.constraint_type,
@@ -349,9 +354,9 @@ const generateIndexes = async (client) => {
         tableConstraints,
     };
 };
-const generateRawEnums = async (client) => {
+const generateRawEnums = async (client, schemas) => {
     const enumListSql = `
-    SELECT
+    SELECT DISTINCT
       n.nspname AS schema_name,
       t.typname AS enum_type,
       e.enumlabel AS enum_value,
@@ -362,6 +367,7 @@ const generateRawEnums = async (client) => {
       pg_type t ON e.enumtypid = t.oid
     JOIN
       pg_namespace n ON t.typnamespace = n.oid
+    ${(0, parseSchema_1.buildSchemaQuery)('n.nspname', schemas, 'WHERE')}
     ORDER BY
       schema_name,
       enum_type,
@@ -371,14 +377,15 @@ const generateRawEnums = async (client) => {
     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] = {
+        const key = `${schema_name}.${enum_type}`;
+        if (!acc[key]) {
+            acc[key] = {
                 name: enum_type,
                 schemaName: schema_name,
                 values: [],
             };
         }
-        acc[enum_type].values.push({
+        acc[key].values.push({
             name: enum_value,
         });
         return acc;
@@ -386,11 +393,12 @@ const generateRawEnums = async (client) => {
     return Object.values(enums);
 };
 const fetchSchemaJson = async (connection) => {
-    const client = await getValidatedClient(connection);
-    const tablesAndFieldsRes = generateTablesAndFields(client);
-    const indexesRes = generateIndexes(client);
-    const refsRes = generateRawRefs(client);
-    const enumsRes = generateRawEnums(client);
+    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 refsRes = generateRawRefs(client, schemas);
+    const enumsRes = generateRawEnums(client, schemas);
     const res = await Promise.all([
         tablesAndFieldsRes,
         indexesRes,

package/dist/connectors/snowflakeConnector.d.ts

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