@dbml/connector 5.1.0 → 5.3.0

package/src/connectors/{bigqueryConnector.ts → bigquery/index.ts}

@@ -1,5 +1,5 @@
 import { BigQuery, BigQueryOptions } from '@google-cloud/bigquery';
-import { loadCredentialFromFile, parseBigQueryCredential } from '../utils/credential-loader';
+import { loadCredentialFromFile, parseBigQueryCredential } from '../../utils/credential-loader';
 import {
   getIntersection,
   getTableSchemaKey,
@@ -7,7 +7,7 @@ import {
   mergeIndexDictionary,
   mergeTableConstraintDictionary,
   mergeTables,
-} from '../utils/helpers';
+} from '../../utils/helpers';
 import {
   BigQueryCredentials,
   DatabaseSchema,
@@ -19,7 +19,7 @@ import {
   IndexesDictionary,
   Table,
   TableConstraintsDictionary,
-} from './types';
+} from '../types';
 
 // BigQuery client authentication strategy:
 // 1. Start with environment/default authentication:
@@ -72,8 +72,7 @@ function getDbDefault (
 
   if (defaultValueType === 'string') {
     // bigquery store the double qoutes and quotes at the end and the beginning of the string: "string" or 'string'
-    // eslint-disable-next-line no-useless-escape
-    return { value: columnDefault.slice(1, -1).replaceAll("'", "\'"), type: defaultValueType };
+    return { value: columnDefault.slice(1, -1).replaceAll('\'', '\''), type: defaultValueType };
   }
 
   return { value: columnDefault, type: defaultValueType };

package/src/connectors/connector.ts

@@ -1,9 +1,10 @@
 import { DatabaseSchema } from './types';
-import { fetchSchemaJson as fetchPostgresSchemaJson } from './postgresConnector';
-import { fetchSchemaJson as fetchMssqlSchemaJson } from './mssqlConnector';
-import { fetchSchemaJson as fetchMysqlSchemaJson } from './mysqlConnector';
-import { fetchSchemaJson as fetchSnowflakeSchemaJson } from './snowflakeConnector';
-import { fetchSchemaJson as fetchBigQuerySchemaJson } from './bigqueryConnector';
+import { fetchSchemaJson as fetchPostgresSchemaJson } from './postgres';
+import { fetchSchemaJson as fetchMssqlSchemaJson } from './mssql';
+import { fetchSchemaJson as fetchMysqlSchemaJson } from './mysql';
+import { fetchSchemaJson as fetchSnowflakeSchemaJson } from './snowflake';
+import { fetchSchemaJson as fetchBigQuerySchemaJson } from './bigquery';
+import { fetchSchemaJson as fetchOracleSchemaJson } from './oracle';
 
 const fetchSchemaJson = async (connection: string, databaseType: string): Promise<DatabaseSchema> => {
   switch (databaseType) {
@@ -17,6 +18,8 @@ const fetchSchemaJson = async (connection: string, databaseType: string): Promis
       return fetchSnowflakeSchemaJson(connection);
     case 'bigquery':
       return fetchBigQuerySchemaJson(connection);
+    case 'oracle':
+      return fetchOracleSchemaJson(connection);
     default:
       throw new Error(`Unsupported database type: ${databaseType}`);
   }

package/src/connectors/{mssqlConnector.ts → mssql/index.ts}

@@ -1,11 +1,10 @@
-/* eslint-disable camelcase */
 /* TDD 72
  * - In MSSQL, there's no notion of ENUM.
  * - MSSQL connector used to extract ENUMS from CHECK constraints, for example: `CHECK ([col]=value1 OR [col]=value2)` would be translated to an enum with 2 values, `value1` and `value2`.
  * - 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.
  * */
 import sql from 'mssql';
-import { buildSchemaQuery, parseConnectionString } from '../utils/parseSchema';
+import { buildSchemaQuery, parseConnectionString } from '../../utils/parseSchema';
 import {
   CheckConstraintDictionary,
   DatabaseSchema,
@@ -18,7 +17,7 @@ import {
   RefEndpoint,
   Table,
   TableConstraintsDictionary,
-} from './types';
+} from '../types';
 
 // https://learn.microsoft.com/en-us/sql/t-sql/data-types/date-and-time-types?view=sql-server-ver15
 const MSSQL_DATE_TYPES = [
@@ -147,8 +146,8 @@ const generateField = (row: Record<string, any>): Field => {
 };
 
 const generateTablesFields = async (client: sql.ConnectionPool, schemas: string[]): Promise<{
-  tables: Table[],
-  fields: FieldsDictionary,
+  tables: Table[];
+  fields: FieldsDictionary;
 }> => {
   const fields: FieldsDictionary = {};
   const tablesAndFieldsSql = `
@@ -293,9 +292,9 @@ const generateRefs = async (client: sql.ConnectionPool, schemas: string[]): Prom
     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]),
+        && endpoint.schemaName === ep2[index].schemaName
+        && endpoint.fieldNames.length === ep2[index].fieldNames.length
+        && endpoint.fieldNames.every((field, fieldIndex) => field === ep2[index].fieldNames[fieldIndex]),
     );
   };
 
@@ -333,7 +332,7 @@ const generateRefs = async (client: sql.ConnectionPool, schemas: string[]): Prom
       onUpdate: on_update === 'NO_ACTION' ? null : on_update,
     };
 
-    const isDuplicate = refs.some(ref => endpointsEqual(ref.endpoints, newRef.endpoints));
+    const isDuplicate = refs.some((ref) => endpointsEqual(ref.endpoints, newRef.endpoints));
 
     if (!isDuplicate) {
       refs.push(newRef);
@@ -439,6 +438,8 @@ const generateIndexesAndConstraints = async (client: sql.ConnectionPool, schemas
       index_type,
       columns,
       expressions,
+      is_unique,
+      is_primary,
     } = indexRow;
     const indexColumns = columns.split(',').map((column: string) => {
       return {
@@ -447,12 +448,14 @@ const generateIndexesAndConstraints = async (client: sql.ConnectionPool, schemas
       };
     });
 
-    const indexExpressions = expressions ? expressions.split(',').map((expression: string) => {
-      return {
-        type: 'expression',
-        value: expression,
-      };
-    }) : [];
+    const indexExpressions = expressions
+      ? expressions.split(',').map((expression: string) => {
+          return {
+            type: 'expression',
+            value: expression,
+          };
+        })
+      : [];
 
     const index = {
       name: index_name,
@@ -461,6 +464,8 @@ const generateIndexesAndConstraints = async (client: sql.ConnectionPool, schemas
         ...indexColumns,
         ...indexExpressions,
       ],
+      pk: !!is_primary,
+      unique: !is_primary && !!is_unique,
     };
 
     const key = `${table_schema}.${table_name}`;

package/src/connectors/{mysqlConnector.ts → mysql/index.ts}

@@ -2,7 +2,7 @@ import { createConnection, Connection } from 'mysql2/promise';
 import { flatten } from 'lodash';
 import {
   CheckConstraintDictionary, DefaultInfo, DatabaseSchema, DefaultType, Field, IndexColumn, FieldsDictionary, Table, Enum, IndexesDictionary, TableConstraintsDictionary, Index, Ref,
-} from './types';
+} from '../types';
 
 const NUMBER_REGEX = '^-?[0-9]+(.[0-9]+)?$';
 
@@ -342,7 +342,7 @@ async function generatePrimaryAndUniqueConstraint (client: Connection, schemaNam
     }
 
     if (constraintType === 'PRIMARY KEY') {
-      acc[key][constraintName].primary = true;
+      acc[key][constraintName].pk = true;
     }
 
     if (constraintType === 'UNIQUE') {
@@ -395,7 +395,7 @@ function extractColumnsFromCheckConstraint (checkClause: string): string[] {
   return [...checkClause.matchAll(/`(?:``|[^`])*`/g)].map((col) => col.toString().slice(1, -1));
 }
 
-async function generateCheckConstraints (client: Connection, schemaName: string): Promise<{ checks: CheckConstraintDictionary, tableConstraints: TableConstraintsDictionary }> {
+async function generateCheckConstraints (client: Connection, schemaName: string): Promise<{ checks: CheckConstraintDictionary; tableConstraints: TableConstraintsDictionary }> {
   const query = `
     select
       cc.constraint_name as constraintName,

package/src/connectors/oracle/constraints.ts

@@ -0,0 +1,113 @@
+import { Connection } from 'oracledb';
+import { CheckConstraint, CheckConstraintDictionary, Index, IndexesDictionary, TableConstraintsDictionary } from '../types';
+import { EXECUTE_OPTIONS, LIST_SEPARATOR } from './utils';
+
+export async function generateConstraints (client: Connection): Promise<{
+  indexes: IndexesDictionary;
+  tableConstraints: TableConstraintsDictionary;
+  checks: CheckConstraintDictionary;
+}> {
+  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, '${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: IndexesDictionary = {};
+  const tableConstraints: TableConstraintsDictionary = {};
+  const checks: CheckConstraintDictionary = {};
+
+  const res = await client.execute(query, [], EXECUTE_OPTIONS);
+  res.rows?.forEach((row) => {
+    const { constraint_name, table_name, columns: columnsStr, column_count, check_expression, constraint_type } = row as Record<string, unknown>;
+    const tableName = table_name as string;
+    const constraintName = (constraint_name as string) || '';
+    const columns = ((columnsStr as string) || '').split(LIST_SEPARATOR);
+    const columnCount = (column_count as number) || 1;
+    const constraintType = constraint_type as 'P' | 'U' | 'C';
+    const checkExpression = (check_expression || null) as string | null;
+
+    // Table-level check constraints
+    if (constraintType === 'C' && checkExpression && columnCount > 1) {
+      if (!checks[tableName]) checks[tableName] = [];
+      const check: CheckConstraint = {
+        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: 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/src/connectors/oracle/index.ts

@@ -0,0 +1,76 @@
+import { getConnection, Connection } from 'oracledb';
+import { DatabaseSchema } from '../types';
+import { generateTablesAndFields } from './tables';
+import { generateRawRefs } from './refs';
+import { generateConstraints } from './constraints';
+import { generateIndexes } from './indexes';
+import { processEasyConnectString } from './utils';
+
+const getValidatedClient = async (username: string, password: string, dbidentifier: string): Promise<Connection> => {
+  const client = await 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: string): Promise<DatabaseSchema> {
+  const { username, password, dbidentifier } = processEasyConnectString(connection);
+
+  const client = await getValidatedClient(username, password, dbidentifier);
+
+  const tablesAndFieldsRes = generateTablesAndFields(client);
+  const constraintsRes = generateConstraints(client);
+  const refsRes = generateRawRefs(client);
+  const indexesRes = 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,
+  };
+};
+
+export {
+  fetchSchemaJson,
+};

package/src/connectors/oracle/indexes.ts

@@ -0,0 +1,71 @@
+import { Connection } from 'oracledb';
+import { Index, IndexesDictionary } from '../types';
+import { EXECUTE_OPTIONS } from './utils';
+
+export async function generateIndexes (client: Connection): Promise<IndexesDictionary> {
+  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, [], EXECUTE_OPTIONS);
+
+  const indexes: IndexesDictionary = {};
+  const indexMap: Record<string, { table: string; type: string; unique: boolean; columns: Array<{ type: 'column' | 'expression'; value: string }> }> = {};
+
+  res.rows?.forEach((row) => {
+    const { index_name, table_name, index_type, is_unique, column_name, column_expression } = row as Record<string, unknown>;
+
+    const name = index_name as string;
+    const table = table_name as string;
+    const type = index_type as string;
+    const unique = !!(is_unique as number);
+
+    if (column_expression) {
+      if (!indexMap[name]) {
+        indexMap[name] = { table, type, unique, columns: [] };
+      }
+      indexMap[name].columns.push({ type: 'expression', value: column_expression as string });
+      return;
+    }
+    if (column_name) {
+      if (!indexMap[name]) {
+        indexMap[name] = { table, type, unique, columns: [] };
+      }
+      indexMap[name].columns.push({ type: 'column', value: column_name as string });
+      return;
+    }
+  });
+
+  Object.entries(indexMap).forEach(([name, { table, type, unique, columns }]) => {
+    const index: Index = { name, type, unique, columns };
+    if (!indexes[table]) indexes[table] = [];
+    indexes[table].push(index);
+  });
+
+  return indexes;
+}

package/src/connectors/oracle/refs.ts

@@ -0,0 +1,73 @@
+import { Connection } from 'oracledb';
+import { Ref, RefEndpoint } from '../types';
+import { EXECUTE_OPTIONS, LIST_SEPARATOR } from './utils';
+
+export async function generateRawRefs (client: Connection): Promise<Ref[]> {
+  const refs: Ref[] = [];
+
+  const refsListSql = `
+    SELECT
+      c.CONSTRAINT_NAME AS "fk_name",
+      c.TABLE_NAME AS "child_table",
+      LISTAGG(cc.COLUMN_NAME, '${LIST_SEPARATOR}') WITHIN GROUP (ORDER BY cc.POSITION) AS "child_columns",
+      p.TABLE_NAME AS "parent_table",
+      LISTAGG(pc.COLUMN_NAME, '${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, [], EXECUTE_OPTIONS);
+  refsQueryResult.rows?.forEach((refRow) => {
+    const { fk_name, child_table, child_columns, parent_table, parent_columns, delete_rule } = refRow as Record<string, string>;
+
+    const ep1: RefEndpoint = {
+      tableName: child_table,
+      schemaName: '',
+      fieldNames: child_columns.split(LIST_SEPARATOR),
+      relation: '*',
+    };
+
+    const ep2: RefEndpoint = {
+      tableName: parent_table,
+      schemaName: '',
+      fieldNames: parent_columns.split(LIST_SEPARATOR),
+      relation: '1',
+    };
+
+    refs.push({
+      name: fk_name,
+      endpoints: [ep1, ep2],
+      onDelete: delete_rule === 'NO ACTION' ? null : delete_rule,
+      onUpdate: null,
+    });
+  });
+
+  return refs;
+}