@dbml/connector 3.7.4 → 3.8.0

package/dist/connectors/bigqueryConnector.d.ts

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

package/dist/connectors/bigqueryConnector.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSchemaJson = fetchSchemaJson;
+const bigquery_1 = require("@google-cloud/bigquery");
+const credential_loader_1 = require("../utils/credential-loader");
+const helpers_1 = require("../utils/helpers");
+async function connectBigQuery(credential) {
+    const client = new bigquery_1.BigQuery({
+        projectId: credential.projectId,
+        credentials: {
+            private_key: credential.credentials.privateKey,
+            client_email: credential.credentials.clientEmail,
+        },
+    });
+    try {
+        const query = `SELECT CURRENT_DATE() as today`;
+        await client.query(query);
+        return client;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`BigQuery connection error: ${error.message}`);
+        }
+        throw error;
+    }
+}
+function getDbDefault(columnDefault, defaultValueType) {
+    if (defaultValueType === null) {
+        return null;
+    }
+    if (defaultValueType === 'string') {
+        // bigquery store the double qoutes and quotes at the end and the beginning of the string: "string" or 'string'
+        return { value: columnDefault.slice(1, -1).replaceAll("'", "\'"), type: defaultValueType };
+    }
+    return { value: columnDefault, type: defaultValueType };
+}
+function generateField(row) {
+    const { columnName, isNullable, dataType, columnDefault, columnDefaultType, columnDescription, } = row;
+    const fieldDefaultValue = getDbDefault(columnDefault, columnDefaultType);
+    const field = {
+        name: columnName,
+        not_null: isNullable === 'NO',
+        type: {
+            type_name: dataType,
+            schemaName: null,
+        },
+        note: {
+            value: columnDescription || '',
+        },
+        dbdefault: fieldDefaultValue,
+        increment: false, // bigquery does not support native auto-increment
+    };
+    return field;
+}
+async function generateTablesAndFields(client, projectId, datasetId) {
+    const tableName = `${projectId}.${datasetId}`;
+    const query = `
+    with
+      table_comments as (
+        select table_schema, table_name, option_value as description
+        from ${tableName}.INFORMATION_SCHEMA.TABLE_OPTIONS
+        where option_name = 'description'
+      ),
+      column_comments as (
+        select column_name, table_schema, table_name, description
+        from ${tableName}.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
+        where column_name = field_path
+      )
+    select
+      t.table_schema as tableSchema,
+      t.table_name as tableName,
+      (select description from table_comments tc where tc.table_name = t.table_name and tc.table_schema = t.table_schema) as tableDescription,
+      (
+        select description
+        from column_comments cc
+        where cc.table_name = c.table_name and cc.table_schema = c.table_schema and cc.column_name = c.column_name
+      ) as columnDescription,
+      c.column_name as columnName,
+      c.is_nullable as isNullable,
+      c.data_type as dataType,
+      c.column_default as columnDefault,
+      CASE
+        WHEN SAFE_CAST(c.column_default AS FLOAT64) IS NOT NULL THEN 'number'
+        WHEN SAFE_CAST(c.column_default AS BOOLEAN) IS NOT NULL THEN 'boolean'
+        -- string value is enclosed in single quotes, double quotes
+        WHEN REGEXP_CONTAINS(c.column_default, r"^['\\"].*['\\"]$") THEN 'string'
+        WHEN c.column_default = "NULL" THEN NULL
+        ELSE 'expression'
+      END AS columnDefaultType
+    from ${tableName}.INFORMATION_SCHEMA.TABLES t
+    join ${tableName}.INFORMATION_SCHEMA.COLUMNS c
+    on
+      t.table_schema = c.table_schema
+      and t.table_name = c.table_name
+    where t.table_type = 'BASE TABLE'
+    order by t.table_name, c.ordinal_position;
+  `;
+    const [queryResult] = await client.query({
+        query,
+        params: {
+        // stringRegex: STRING_REGEX,
+        },
+    });
+    const tableMap = {};
+    const fieldMap = {};
+    queryResult.forEach((row) => {
+        const { tableSchema, tableName, tableComment } = row;
+        const key = (0, helpers_1.getTableSchemaKey)(tableSchema, tableName);
+        if (!tableMap[key]) {
+            tableMap[key] = {
+                name: tableName,
+                note: { value: tableComment || '' },
+                schemaName: tableSchema,
+            };
+        }
+        if (!fieldMap[key]) {
+            fieldMap[key] = [];
+        }
+        const field = generateField(row);
+        fieldMap[key].push(field);
+    });
+    return {
+        tables: Object.values(tableMap),
+        fieldMap,
+    };
+}
+async function generateIndexes(client, projectId, datasetId) {
+    const tableName = `${projectId}.${datasetId}`;
+    const query = `
+    select
+      s.index_schema as indexSchema,
+      s.table_name as tableName,
+      s.index_name as indexName,
+      string_agg(sc.index_column_name, ', ') as indexColumnNames
+    from ${tableName}.INFORMATION_SCHEMA.SEARCH_INDEXES s
+    join ${tableName}.INFORMATION_SCHEMA.SEARCH_INDEX_COLUMNS sc
+    on
+      s.index_schema = sc.index_schema
+      and s.table_name = sc.table_name
+      and s.index_name = sc.index_name
+    where sc.index_column_name = sc.index_field_path
+    group by s.index_schema, s.table_name, s.index_name
+    order by s.table_name, s.index_name;
+  `;
+    const [queryResult] = await client.query(query);
+    const indexMap = {};
+    queryResult.forEach((row) => {
+        const { indexSchema, tableName, indexName, indexColumnNames } = row;
+        const indexColumns = indexColumnNames.split(', ').map((column) => {
+            return {
+                type: 'column',
+                value: column,
+            };
+        });
+        const index = {
+            name: indexName,
+            type: '',
+            columns: [...indexColumns],
+        };
+        const key = (0, helpers_1.getTableSchemaKey)(indexSchema, tableName);
+        if (indexMap[key]) {
+            indexMap[key].push(index);
+        }
+        else {
+            indexMap[key] = [index];
+        }
+    });
+    return indexMap;
+}
+async function generateTableConstraints(client, projectId, datasetId) {
+    const tableName = `${projectId}.${datasetId}`;
+    const query = `
+    select
+      tc.table_schema as tableSchema,
+      tc.table_name as tableName,
+      tc.constraint_name as constraintName,
+      string_agg(kcu.column_name, ', ') as columnNames,
+      count(kcu.column_name) as columnCount,
+    from ${tableName}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+    join ${tableName}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+    on
+      tc.table_schema = kcu.table_schema
+      and tc.table_name = kcu.table_name
+      and tc.constraint_name = kcu.constraint_name
+    where tc.constraint_type = 'PRIMARY KEY'
+    group by tc.table_schema, tc.table_name, tc.constraint_name
+    order by tc.table_name, tc.constraint_name;
+  `;
+    const [queryResult] = await client.query(query);
+    const inlinePrimaryKeyList = queryResult.filter((row) => row.columnCount && row.columnCount === 1);
+    const compositePrimaryKeyList = queryResult.filter((row) => row.columnCount && row.columnCount > 1);
+    const inlinePrimaryKeyMap = {};
+    inlinePrimaryKeyList.forEach((inlineKey) => {
+        const { tableSchema, tableName, columnNames } = inlineKey;
+        const key = (0, helpers_1.getTableSchemaKey)(tableSchema, tableName);
+        if (!inlinePrimaryKeyMap[key]) {
+            inlinePrimaryKeyMap[key] = {};
+        }
+        if (!inlinePrimaryKeyMap[key][columnNames]) {
+            inlinePrimaryKeyMap[key][columnNames] = {};
+        }
+        inlinePrimaryKeyMap[key][columnNames].pk = true;
+    });
+    const compositePrimaryKeyMap = {};
+    compositePrimaryKeyList.forEach((compositeKey) => {
+        const { tableSchema, tableName, constraintName, columnNames } = compositeKey;
+        const indexColumns = columnNames.split(', ').map((column) => {
+            return {
+                type: 'column',
+                value: column,
+            };
+        });
+        const index = {
+            name: constraintName,
+            type: '',
+            columns: [...indexColumns],
+            pk: true,
+        };
+        const key = (0, helpers_1.getTableSchemaKey)(tableSchema, tableName);
+        if (compositePrimaryKeyMap[key]) {
+            compositePrimaryKeyMap[key].push(index);
+        }
+        else {
+            compositePrimaryKeyMap[key] = [index];
+        }
+    });
+    return {
+        inlinePrimaryKeyMap,
+        compositePrimaryKeyMap,
+    };
+}
+async function validateDatasetIdList(client, datasetIdList) {
+    const [datasets] = await client.getDatasets();
+    const rawDatasetIdList = datasets.map((dataset) => dataset.id).filter((id) => id);
+    // If user does not specify which datasets to be fetched, we will fetch all datasets
+    if (datasetIdList.length === 0) {
+        return rawDatasetIdList;
+    }
+    return (0, helpers_1.getIntersection)(datasetIdList, rawDatasetIdList);
+}
+async function fetchSchemaJsonByDataset(client, projectId, datasetId) {
+    const res = await Promise.all([
+        generateTablesAndFields(client, projectId, datasetId),
+        generateIndexes(client, projectId, datasetId),
+        generateTableConstraints(client, projectId, datasetId),
+    ]);
+    const { tables, fieldMap } = res[0];
+    const indexMap = res[1];
+    const { inlinePrimaryKeyMap, compositePrimaryKeyMap } = res[2];
+    return {
+        tables,
+        fields: fieldMap,
+        refs: [],
+        enums: [],
+        indexes: (0, helpers_1.mergeIndexDictionary)(indexMap, compositePrimaryKeyMap),
+        tableConstraints: inlinePrimaryKeyMap,
+    };
+}
+async function fetchSchemaJson(keyFilename) {
+    const rawCredential = await (0, credential_loader_1.loadCredentialFromFile)(keyFilename);
+    const credentialJson = (0, credential_loader_1.parseBigQueryCredential)(rawCredential);
+    const client = await connectBigQuery(credentialJson);
+    const projectId = await client.getProjectId();
+    const datasetIdList = await validateDatasetIdList(client, credentialJson.datasets);
+    const querySchemaPromises = datasetIdList.map((dataset) => fetchSchemaJsonByDataset(client, projectId, dataset));
+    const databaseSchemaRes = await Promise.all(querySchemaPromises);
+    const res = databaseSchemaRes.reduce((acc, dbSchema) => {
+        const { tables, fields, indexes, tableConstraints } = dbSchema;
+        acc.tables = (0, helpers_1.mergeTables)(acc.tables, tables);
+        acc.fields = (0, helpers_1.mergeFieldDictionary)(acc.fields, fields);
+        acc.indexes = (0, helpers_1.mergeIndexDictionary)(acc.indexes, indexes);
+        acc.tableConstraints = (0, helpers_1.mergeTableConstraintDictionary)(acc.tableConstraints, tableConstraints);
+        return acc;
+    }, { tables: [], fields: {}, tableConstraints: {}, indexes: {}, refs: [], enums: [] });
+    return res;
+}

package/dist/connectors/connector.d.ts

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

package/dist/connectors/connector.js

@@ -4,16 +4,22 @@ exports.fetchSchemaJson = void 0;
 const postgresConnector_1 = require("./postgresConnector");
 const mssqlConnector_1 = require("./mssqlConnector");
 const mysqlConnector_1 = require("./mysqlConnector");
-const fetchSchemaJson = async (connection, format) => {
-    switch (format) {
+const snowflakeConnector_1 = require("./snowflakeConnector");
+const bigqueryConnector_1 = require("./bigqueryConnector");
+const fetchSchemaJson = async (connection, databaseType) => {
+    switch (databaseType) {
         case 'postgres':
             return (0, postgresConnector_1.fetchSchemaJson)(connection);
         case 'mssql':
             return (0, mssqlConnector_1.fetchSchemaJson)(connection);
         case 'mysql':
             return (0, mysqlConnector_1.fetchSchemaJson)(connection);
+        case 'snowflake':
+            return (0, snowflakeConnector_1.fetchSchemaJson)(connection);
+        case 'bigquery':
+            return (0, bigqueryConnector_1.fetchSchemaJson)(connection);
         default:
-            throw new Error(`Unsupported connection format: ${format}`);
+            throw new Error(`Unsupported database type: ${databaseType}`);
     }
 };
 exports.fetchSchemaJson = fetchSchemaJson;

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,75 @@ 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,
-            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
-    )
+  WITH tables_and_fields AS (
     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
+      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
-        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;
+      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
+  ${(0, parseSchema_1.buildSchemaQuery)('tf.table_schema', schemas, 'WHERE')}
+  ORDER BY
+    tf.table_schema,
+    tf.table_name,
+    tf.column_name;
   `;
     const tablesAndFieldsResult = await client.query(tablesAndFieldsSql);
     const tables = tablesAndFieldsResult.recordset.reduce((acc, row) => {
@@ -212,7 +209,7 @@ const generateTablesFieldsAndEnums = async (client) => {
         enums,
     };
 };
-const generateRefs = async (client) => {
+const generateRefs = async (client, schemas) => {
     const refs = [];
     const refsListSql = `
     SELECT
@@ -242,6 +239,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 +268,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 +286,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 +334,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 +411,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.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,7 +79,7 @@ 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 (
@@ -129,6 +130,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 +159,7 @@ const generateTablesAndFields = async (client) => {
         fields,
     };
 };
-const generateRawRefs = async (client) => {
+const generateRawRefs = async (client, schemas) => {
     const refs = [];
     const refsListSql = `
     SELECT
@@ -182,6 +184,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 +222,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 +235,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 +260,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 +271,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,7 +353,7 @@ const generateIndexes = async (client) => {
         tableConstraints,
     };
 };
-const generateRawEnums = async (client) => {
+const generateRawEnums = async (client, schemas) => {
     const enumListSql = `
     SELECT
       n.nspname AS schema_name,
@@ -362,6 +366,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,
@@ -386,11 +391,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, };