@dbml/connector 5.2.0 → 5.3.1

package/dist/connectors/{bigqueryConnector.d.ts → bigquery/index.d.ts}

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

package/dist/connectors/{bigqueryConnector.js → bigquery/index.js}

@@ -2,8 +2,8 @@
 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");
+const credential_loader_1 = require("../../utils/credential-loader");
+const helpers_1 = require("../../utils/helpers");
 // BigQuery client authentication strategy:
 // 1. Start with environment/default authentication:
 //    - GOOGLE_APPLICATION_CREDENTIALS env variable (service account key file)

package/dist/connectors/connector.js

@@ -1,23 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchSchemaJson = void 0;
-const postgresConnector_1 = require("./postgresConnector");
-const mssqlConnector_1 = require("./mssqlConnector");
-const mysqlConnector_1 = require("./mysqlConnector");
-const snowflakeConnector_1 = require("./snowflakeConnector");
-const bigqueryConnector_1 = require("./bigqueryConnector");
+const postgres_1 = require("./postgres");
+const mssql_1 = require("./mssql");
+const mysql_1 = require("./mysql");
+const snowflake_1 = require("./snowflake");
+const bigquery_1 = require("./bigquery");
+const oracle_1 = require("./oracle");
 const fetchSchemaJson = async (connection, databaseType) => {
     switch (databaseType) {
         case 'postgres':
-            return (0, postgresConnector_1.fetchSchemaJson)(connection);
+            return (0, postgres_1.fetchSchemaJson)(connection);
         case 'mssql':
-            return (0, mssqlConnector_1.fetchSchemaJson)(connection);
+            return (0, mssql_1.fetchSchemaJson)(connection);
         case 'mysql':
-            return (0, mysqlConnector_1.fetchSchemaJson)(connection);
+            return (0, mysql_1.fetchSchemaJson)(connection);
         case 'snowflake':
-            return (0, snowflakeConnector_1.fetchSchemaJson)(connection);
+            return (0, snowflake_1.fetchSchemaJson)(connection);
         case 'bigquery':
-            return (0, bigqueryConnector_1.fetchSchemaJson)(connection);
+            return (0, bigquery_1.fetchSchemaJson)(connection);
+        case 'oracle':
+            return (0, oracle_1.fetchSchemaJson)(connection);
         default:
             throw new Error(`Unsupported database type: ${databaseType}`);
     }

package/dist/connectors/{mssqlConnector.d.ts → mssql/index.d.ts}

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

package/dist/connectors/{mssqlConnector.js → mssql/index.js}

@@ -10,7 +10,7 @@ exports.fetchSchemaJson = void 0;
  * - 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");
+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
 const MSSQL_DATE_TYPES = [
     'date',

package/dist/connectors/{mysqlConnector.d.ts → mysql/index.d.ts}

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

package/dist/connectors/oracle/constraints.d.ts

@@ -0,0 +1,7 @@
+import { Connection } from 'oracledb';
+import { CheckConstraintDictionary, IndexesDictionary, TableConstraintsDictionary } from '../types';
+export declare function generateConstraints(client: Connection): Promise<{
+    indexes: IndexesDictionary;
+    tableConstraints: TableConstraintsDictionary;
+    checks: CheckConstraintDictionary;
+}>;

package/dist/connectors/oracle/constraints.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateConstraints = generateConstraints;
+const utils_1 = require("./utils");
+async function generateConstraints(client) {
+    const query = `
+    WITH all_constraints AS (
+      SELECT
+        c.CONSTRAINT_NAME,
+        c.TABLE_NAME,
+        c.CONSTRAINT_TYPE,
+        c.SEARCH_CONDITION_VC AS CHECK_EXPRESSION
+      FROM USER_CONSTRAINTS c
+      WHERE c.CONSTRAINT_TYPE IN ('P', 'U', 'C') -- P stands for primary key, U stands for unique and C stands for check
+        AND (c.CONSTRAINT_TYPE != 'C' OR UPPER(c.SEARCH_CONDITION_VC) NOT LIKE '%IS NOT NULL')
+    ),
+    constraint_columns AS (
+      SELECT
+        cc.CONSTRAINT_NAME,
+        LISTAGG(cc.COLUMN_NAME, '${utils_1.LIST_SEPARATOR}') WITHIN GROUP (ORDER BY cc.POSITION) AS COLUMNS,
+        COUNT(cc.COLUMN_NAME) AS COLUMN_COUNT
+      FROM USER_CONS_COLUMNS cc
+      GROUP BY cc.CONSTRAINT_NAME
+    )
+    SELECT
+      ac.CONSTRAINT_NAME AS "constraint_name",
+      ac.TABLE_NAME AS "table_name",
+      cc.COLUMNS AS "columns",
+      cc.COLUMN_COUNT AS "column_count",
+      ac.CHECK_EXPRESSION AS "check_expression",
+      ac.CONSTRAINT_TYPE AS "constraint_type"
+    FROM all_constraints ac
+    LEFT JOIN constraint_columns cc
+      ON ac.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
+    LEFT JOIN USER_OBJECTS obj
+      ON obj.OBJECT_NAME = ac.TABLE_NAME
+      AND obj.OBJECT_TYPE = 'TABLE'
+    ORDER BY
+      obj.CREATED,
+      obj.OBJECT_ID,
+      ac.CONSTRAINT_NAME
+  `;
+    const indexes = {};
+    const tableConstraints = {};
+    const checks = {};
+    const res = await client.execute(query, [], utils_1.EXECUTE_OPTIONS);
+    res.rows?.forEach((row) => {
+        const { constraint_name, table_name, columns: columnsStr, column_count, check_expression, constraint_type } = row;
+        const tableName = table_name;
+        const constraintName = constraint_name || '';
+        const columns = (columnsStr || '').split(utils_1.LIST_SEPARATOR);
+        const columnCount = column_count || 1;
+        const constraintType = constraint_type;
+        const checkExpression = (check_expression || null);
+        // Table-level check constraints
+        if (constraintType === 'C' && checkExpression && columnCount > 1) {
+            if (!checks[tableName])
+                checks[tableName] = [];
+            const check = {
+                name: constraintName,
+                expression: checkExpression,
+            };
+            checks[tableName].push(check);
+            return;
+        }
+        // Column-level check constraints
+        if (constraintType === 'C' && checkExpression && columnCount === 1 && columns.length === 1) {
+            if (!tableConstraints[tableName])
+                tableConstraints[tableName] = {};
+            const column = columns[0];
+            if (!tableConstraints[tableName][column])
+                tableConstraints[tableName][column] = { checks: [] };
+            tableConstraints[tableName][column].checks.push({
+                name: constraintName,
+                expression: checkExpression,
+            });
+        }
+        // Column-level unique or primary indexes
+        if (['P', 'U'].includes(constraintType) && columnCount === 1 && columns.length === 1) {
+            if (!tableConstraints[tableName])
+                tableConstraints[tableName] = {};
+            const column = columns[0];
+            if (!tableConstraints[tableName][column])
+                tableConstraints[tableName][column] = { checks: [] };
+            tableConstraints[tableName][column].pk ||= constraintType === 'P';
+            tableConstraints[tableName][column].unique ||= constraintType === 'U';
+        }
+        // Table-level unique or primary indexes
+        if (['P', 'U'].includes(constraintType) && columnCount > 1) {
+            if (!tableConstraints[tableName])
+                tableConstraints[tableName] = {};
+            if (!indexes[tableName])
+                indexes[tableName] = [];
+            const index = {
+                name: constraintName,
+                type: '',
+                unique: true,
+                pk: constraintType === 'P',
+                columns: columns.map((c) => ({
+                    type: 'column',
+                    value: c,
+                })),
+            };
+            indexes[tableName].push(index);
+        }
+    });
+    return {
+        indexes,
+        tableConstraints,
+        checks,
+    };
+}

package/dist/connectors/oracle/index.d.ts

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

package/dist/connectors/oracle/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSchemaJson = fetchSchemaJson;
+const oracledb_1 = require("oracledb");
+const tables_1 = require("./tables");
+const refs_1 = require("./refs");
+const constraints_1 = require("./constraints");
+const indexes_1 = require("./indexes");
+const utils_1 = require("./utils");
+const getValidatedClient = async (username, password, dbidentifier) => {
+    const client = await (0, oracledb_1.getConnection)({
+        username,
+        password,
+        connectionString: dbidentifier,
+    });
+    try {
+        await client.execute('SELECT 1 FROM DUAL');
+        return client;
+    }
+    catch (error) {
+        await client.close();
+        if (error instanceof Error) {
+            throw new Error(`OracleSQL connection error: ${error.message}`);
+        }
+        throw error;
+    }
+};
+// Expect an Easy Connect string format: username/password@[//]host[:port][/database]
+// `username` and `password` are mandatory
+// `port` and `database` (and the parts enclosed in `[]`) are optional
+// Explanation of the format: https://www.orafaq.com/wiki/EZCONNECT
+async function fetchSchemaJson(connection) {
+    const { username, password, dbidentifier } = (0, utils_1.processEasyConnectString)(connection);
+    const client = await getValidatedClient(username, password, dbidentifier);
+    const tablesAndFieldsRes = (0, tables_1.generateTablesAndFields)(client);
+    const constraintsRes = (0, constraints_1.generateConstraints)(client);
+    const refsRes = (0, refs_1.generateRawRefs)(client);
+    const indexesRes = (0, indexes_1.generateIndexes)(client);
+    const res = await Promise.all([
+        tablesAndFieldsRes,
+        constraintsRes,
+        refsRes,
+        indexesRes,
+    ]);
+    const { tables, fields } = res[0];
+    const { indexes: uniqueIndexes, tableConstraints, checks } = res[1];
+    const refs = res[2];
+    const indexes = res[3];
+    Object.keys(uniqueIndexes).forEach((key) => {
+        if (!indexes[key])
+            indexes[key] = uniqueIndexes[key];
+        else
+            indexes[key].push(...uniqueIndexes[key]);
+    });
+    await client.close();
+    return {
+        tables,
+        fields,
+        refs,
+        // As of oracle 19c, there's no native ENUM data type
+        // ENUM is introduced in oracle 23ai
+        enums: [],
+        indexes,
+        tableConstraints,
+        checks,
+    };
+}
+;

package/dist/connectors/oracle/indexes.d.ts

@@ -0,0 +1,3 @@
+import { Connection } from 'oracledb';
+import { IndexesDictionary } from '../types';
+export declare function generateIndexes(client: Connection): Promise<IndexesDictionary>;

package/dist/connectors/oracle/indexes.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIndexes = generateIndexes;
+const utils_1 = require("./utils");
+async function generateIndexes(client) {
+    const query = `
+    SELECT
+      i.INDEX_NAME AS "index_name",
+      i.TABLE_NAME AS "table_name",
+      CASE
+        WHEN i.INDEX_TYPE LIKE '%NORMAL' THEN 'btree'
+        ELSE LOWER(REGEXP_REPLACE(i.INDEX_TYPE, '^FUNCTION-BASED ', ''))
+      END AS "index_type",
+      CASE WHEN i.UNIQUENESS = 'UNIQUE' THEN 1 ELSE 0 END AS "is_unique",
+      ic.COLUMN_NAME AS "column_name",
+      ic.COLUMN_POSITION AS "column_position",
+      ie.COLUMN_EXPRESSION AS "column_expression"
+    FROM USER_INDEXES i
+    LEFT JOIN USER_IND_COLUMNS ic
+      ON i.INDEX_NAME = ic.INDEX_NAME
+    LEFT JOIN USER_IND_EXPRESSIONS ie
+      ON i.INDEX_NAME = ie.INDEX_NAME
+      AND ic.COLUMN_POSITION = ie.COLUMN_POSITION
+    LEFT JOIN USER_OBJECTS obj
+      ON obj.OBJECT_NAME = i.TABLE_NAME
+      AND obj.OBJECT_TYPE = 'TABLE'
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM USER_CONSTRAINTS c
+      WHERE c.INDEX_NAME = i.INDEX_NAME
+    )
+    ORDER BY obj.CREATED, obj.OBJECT_ID, i.INDEX_NAME, ic.COLUMN_POSITION
+  `;
+    const res = await client.execute(query, [], utils_1.EXECUTE_OPTIONS);
+    const indexes = {};
+    const indexMap = {};
+    res.rows?.forEach((row) => {
+        const { index_name, table_name, index_type, is_unique, column_name, column_expression } = row;
+        const name = index_name;
+        const table = table_name;
+        const type = index_type;
+        const unique = !!is_unique;
+        if (column_expression) {
+            if (!indexMap[name]) {
+                indexMap[name] = { table, type, unique, columns: [] };
+            }
+            indexMap[name].columns.push({ type: 'expression', value: column_expression });
+            return;
+        }
+        if (column_name) {
+            if (!indexMap[name]) {
+                indexMap[name] = { table, type, unique, columns: [] };
+            }
+            indexMap[name].columns.push({ type: 'column', value: column_name });
+            return;
+        }
+    });
+    Object.entries(indexMap).forEach(([name, { table, type, unique, columns }]) => {
+        const index = { name, type, unique, columns };
+        if (!indexes[table])
+            indexes[table] = [];
+        indexes[table].push(index);
+    });
+    return indexes;
+}

package/dist/connectors/oracle/refs.d.ts

@@ -0,0 +1,3 @@
+import { Connection } from 'oracledb';
+import { Ref } from '../types';
+export declare function generateRawRefs(client: Connection): Promise<Ref[]>;

package/dist/connectors/oracle/refs.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRawRefs = generateRawRefs;
+const utils_1 = require("./utils");
+async function generateRawRefs(client) {
+    const refs = [];
+    const refsListSql = `
+    SELECT
+      c.CONSTRAINT_NAME AS "fk_name",
+      c.TABLE_NAME AS "child_table",
+      LISTAGG(cc.COLUMN_NAME, '${utils_1.LIST_SEPARATOR}') WITHIN GROUP (ORDER BY cc.POSITION) AS "child_columns",
+      p.TABLE_NAME AS "parent_table",
+      LISTAGG(pc.COLUMN_NAME, '${utils_1.LIST_SEPARATOR}') WITHIN GROUP (ORDER BY pc.POSITION) AS "parent_columns",
+      c.DELETE_RULE AS "delete_rule"
+    FROM USER_CONSTRAINTS c
+    JOIN USER_CONSTRAINTS p
+      ON c.R_CONSTRAINT_NAME = p.CONSTRAINT_NAME
+    JOIN USER_CONS_COLUMNS cc
+      ON c.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
+    JOIN USER_CONS_COLUMNS pc
+      ON p.CONSTRAINT_NAME = pc.CONSTRAINT_NAME
+      AND cc.POSITION = pc.POSITION
+    LEFT JOIN USER_OBJECTS obj_child
+      ON obj_child.OBJECT_NAME = c.TABLE_NAME
+      AND obj_child.OBJECT_TYPE = 'TABLE'
+    LEFT JOIN USER_OBJECTS obj_parent
+      ON obj_parent.OBJECT_NAME = p.TABLE_NAME
+      AND obj_parent.OBJECT_TYPE = 'TABLE'
+    WHERE c.CONSTRAINT_TYPE = 'R'
+    GROUP BY
+      c.CONSTRAINT_NAME,
+      c.TABLE_NAME,
+      p.TABLE_NAME,
+      c.DELETE_RULE,
+      obj_child.CREATED,
+      obj_child.OBJECT_ID,
+      obj_parent.CREATED,
+      obj_parent.OBJECT_ID
+    ORDER BY
+      obj_child.CREATED,
+      obj_child.OBJECT_ID,
+      c.CONSTRAINT_NAME
+  `;
+    const refsQueryResult = await client.execute(refsListSql, [], utils_1.EXECUTE_OPTIONS);
+    refsQueryResult.rows?.forEach((refRow) => {
+        const { fk_name, child_table, child_columns, parent_table, parent_columns, delete_rule } = refRow;
+        const ep1 = {
+            tableName: child_table,
+            schemaName: '',
+            fieldNames: child_columns.split(utils_1.LIST_SEPARATOR),
+            relation: '*',
+        };
+        const ep2 = {
+            tableName: parent_table,
+            schemaName: '',
+            fieldNames: parent_columns.split(utils_1.LIST_SEPARATOR),
+            relation: '1',
+        };
+        refs.push({
+            name: fk_name,
+            endpoints: [ep1, ep2],
+            onDelete: delete_rule === 'NO ACTION' ? null : delete_rule,
+            onUpdate: null,
+        });
+    });
+    return refs;
+}

package/dist/connectors/oracle/tables.d.ts

@@ -0,0 +1,7 @@
+import { Connection } from 'oracledb';
+import { FieldsDictionary, Table } from '../types';
+export declare function generateTablesAndFields(client: Connection): Promise<{
+    tables: Table[];
+    fields: FieldsDictionary;
+}>;
+export declare function getFieldType(dataType: string, characterMaximumLength: number, numericPrecision: number | null, numericScale: number | null): string;