@dbml/connector 5.2.0 → 5.3.1

package/dist/connectors/oracle/tables.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTablesAndFields = generateTablesAndFields;
+exports.getFieldType = getFieldType;
+const utils_1 = require("./utils");
+async function generateTablesAndFields(client) {
+    const fields = {};
+    // Note: DATA_DEFAULT is LONG type which doesn't support SQL string operations
+    // The oracledb driver fetches LONG as string, so we detect default type in JavaScript
+    const tablesAndFieldsSql = `
+    SELECT
+      cols.TABLE_NAME AS "table_name",
+      cols.COLUMN_NAME AS "column_name",
+      cols.COLUMN_ID AS "column_id",
+      cols.DATA_TYPE AS "data_type",
+      cols.DATA_LENGTH AS "data_length",
+      cols.DATA_PRECISION AS "data_precision",
+      cols.DATA_SCALE AS "data_scale",
+      CASE WHEN cols.IDENTITY_COLUMN = 'YES' THEN 1 ELSE 0 END AS "identity_increment",
+      CASE WHEN cols.NULLABLE = 'Y' THEN 1 ELSE 0 END AS "is_nullable",
+      cols.DATA_DEFAULT AS "data_default",
+      tcoms.COMMENTS AS "table_comment",
+      ccoms.COMMENTS AS "column_comment",
+      obj.CREATED AS "table_created"
+    FROM USER_TAB_COLUMNS cols
+    LEFT JOIN USER_COL_COMMENTS ccoms
+      ON ccoms.COLUMN_NAME = cols.COLUMN_NAME
+      AND ccoms.TABLE_NAME = cols.TABLE_NAME
+    LEFT JOIN USER_TAB_COMMENTS tcoms
+      ON tcoms.TABLE_NAME = cols.TABLE_NAME
+    LEFT JOIN USER_OBJECTS obj
+      ON obj.OBJECT_NAME = cols.TABLE_NAME
+      AND obj.OBJECT_TYPE = 'TABLE'
+    ORDER BY obj.CREATED, obj.OBJECT_ID, cols.COLUMN_ID
+  `;
+    const tablesAndFieldsResult = await client.execute(tablesAndFieldsSql, [], utils_1.EXECUTE_OPTIONS);
+    const tableMap = tablesAndFieldsResult.rows?.reduce((acc, row) => {
+        const { table_name, table_comment } = row;
+        if (!acc[table_name]) {
+            acc[table_name] = {
+                name: table_name,
+                schemaName: '',
+                note: table_comment ? { value: table_comment } : { value: '' },
+            };
+        }
+        if (!fields[table_name])
+            fields[table_name] = [];
+        const field = generateField(row);
+        fields[table_name].push(field);
+        return acc;
+    }, {}) || {};
+    return {
+        tables: Object.values(tableMap),
+        fields,
+    };
+}
+// Field utils
+function getDefaultType(columnDefault) {
+    if (columnDefault === null || columnDefault === undefined) {
+        return 'expression';
+    }
+    const trimmed = columnDefault.trim();
+    // String defaults are wrapped in single quotes: 'value'
+    // Example: `'string'`, `'string with quotes'''`
+    if (/^'.*'$/.test(trimmed)) {
+        return 'string';
+    }
+    // Number defaults are integers or non-scientific floats
+    // Example: `123`, `0.12`, `.12`, `12.`
+    if (/^[0-9]+$/.test(trimmed) || /^[0-9]*\.[0-9]*$/.test(trimmed)) {
+        return 'number';
+    }
+    // Example: Strings that are not enclosed in `'` or do not contain only numbers and `.`
+    //   * CURRENT_TIMESTAMP
+    //   * SYSDATE
+    //   * "number-column" + 2
+    return 'expression';
+}
+function generateField(row) {
+    const { column_name, data_type, data_length, data_precision, data_scale, identity_increment, is_nullable, data_default, column_comment, } = row;
+    const defaultType = getDefaultType(data_default);
+    const dbdefault = data_default && !identity_increment ? getDbdefault(data_default, defaultType) : null;
+    const fieldType = {
+        type_name: getFieldType(data_type, data_length, data_precision, data_scale),
+        schemaName: null,
+    };
+    return {
+        name: column_name,
+        type: fieldType,
+        dbdefault,
+        not_null: !is_nullable,
+        increment: !!identity_increment,
+        note: column_comment ? { value: column_comment } : { value: '' },
+    };
+}
+// Field default utils
+function getDbdefault(columnDefault, defaultType) {
+    if (columnDefault === null) {
+        return null;
+    }
+    if (defaultType === 'string') {
+        const trimmed = columnDefault.trim();
+        return {
+            value: trimmed.slice(1, -1) // slice off single quotes at the start and end of the value
+                .replaceAll('\'\'', '\''), // escape sequences are preserved: in oracle, double single quotes = escape a single quote
+            type: defaultType,
+        };
+    }
+    return { value: columnDefault, type: defaultType };
+}
+// Field type utils
+// These datatypes are never qualified: data size, data scale and data precision are all ignore.
+// Ref: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Data-Types.html
+const UNQUALIFIED_DATA_TYPES = new Set([
+    // datetime
+    'date',
+    // number
+    'binary_float',
+    'binary_double',
+    // long and raw
+    'long',
+    'long raw',
+    // large object
+    'blob',
+    'clob',
+    'nclob',
+    'bfile',
+    // rowid
+    'rowid',
+    // ansi supported
+    'integer',
+    'int',
+    'smallint',
+    'double precision',
+    'real',
+    // any
+    'AnyData',
+    'AnyType',
+    'AnyDataSet',
+    // xml
+    'XMLType',
+    'URIType',
+    // spatial
+    'SDO_Geometry',
+    'SDO_Topo_Geometry',
+    'SDO_GeoRaster',
+]);
+// These datatypes can be and only be qualified with data size
+// For simplicity the data size in bytes is assumed
+// Ref: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Data-Types.html
+const SIZED_DATA_TYPES = new Set([
+    // character
+    'char',
+    'varchar2',
+    'nchar',
+    'nvarchar2',
+    // long and raw
+    'raw',
+    // rowid
+    'urowid',
+    // ansi supported
+    'character varying',
+    'character',
+    'char varying',
+    'nchar varying',
+    'varchar',
+    'national character varying',
+    'national character',
+    'national char varying',
+    'national char',
+]);
+// These datatypes can be and only be qualified with precision
+// For datetime, these are the types that only have 1 precision
+// Ref: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Data-Types.html
+const PRECISION_DATA_TYPES = new Set([
+    // number
+    'float',
+]);
+// This datatype can be qualified with a fractional second precision
+const TIMESTAMP_WITH_LOCAL_TIME_ZONE_DATA_TYPE = 'timestamp with local time zone';
+// This datatype can be qualified with a second precision
+const TIMESTAMP_WITH_TIME_ZONE_DATA_TYPE = 'timestamp with time zone';
+// This datatype can be qualified with a second precision
+const TIMESTAMP_DATA_TYPE = 'timestamp';
+// This datatype can be qualified with a year precision
+const INTERVAL_YEAR_DATA_TYPE = 'interval year to month';
+// This datatype can be qualified with a day precision and a fraction second precision
+const INTERVAL_DAY_DATA_TYPE = 'interval day to second';
+// These datatypes can be and only be qualified with precision and scale
+// For datetime, these are the types that can have 2 precisions
+// Ref: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Data-Types.html
+const PRECISION_SCALED_DATA_TYPES = new Set([
+    // number
+    'number',
+    // ansi supported
+    'numeric',
+    'decimal',
+    'dec',
+]);
+// Format the field type to a standard string for aesthetic when exporting to DBML (`ANYDATA`, `anydata` are all normalized to `AnyData`)
+// Some types contain multiple words with arbitrary spaces, for example, `TIMESTAMP (6)   WITH LOCAL TIME ZONE`, we should normalize this to allow processing to be uniform, for example when checking for equality
+function normalizeFieldType(dataType) {
+    const normalizedDataType = dataType.split(' ').filter(Boolean).join(' ').toLowerCase();
+    switch (normalizedDataType) {
+        case 'anydata':
+            return 'AnyData';
+        case 'anytype':
+            return 'AnyType';
+        case 'anydataset':
+            return 'AnyDataSet';
+        case 'xmltype':
+            return 'XMLType';
+        case 'uritype':
+            return 'URIType';
+        case 'sdo_geometry':
+            return 'SDO_Geometry';
+        case 'sdo_topo_geometry':
+            return 'SDO_Topo_Geometry';
+        case 'sdo_georaster':
+            return 'SDO_GeoRaster';
+        default:
+            return normalizedDataType;
+    }
+}
+function getFieldType(dataType, characterMaximumLength, numericPrecision, numericScale) {
+    const normalizedDataType = normalizeFieldType(dataType);
+    if (normalizedDataType === TIMESTAMP_WITH_LOCAL_TIME_ZONE_DATA_TYPE) {
+        if (numericScale !== null)
+            return `timestamp (${numericScale}) with local time zone`;
+        return normalizedDataType;
+    }
+    if (normalizedDataType === TIMESTAMP_WITH_TIME_ZONE_DATA_TYPE) {
+        if (numericScale !== null)
+            return `timestamp (${numericScale}) with time zone`;
+        return normalizedDataType;
+    }
+    if (normalizedDataType === TIMESTAMP_DATA_TYPE) {
+        if (numericScale !== null)
+            return `timestamp (${numericScale})`;
+        return normalizedDataType;
+    }
+    if (normalizedDataType === INTERVAL_YEAR_DATA_TYPE) {
+        if (numericPrecision !== null)
+            return `interval year (${numericPrecision}) to month`;
+        return normalizedDataType;
+    }
+    if (normalizedDataType === INTERVAL_DAY_DATA_TYPE) {
+        if (numericPrecision !== null && numericScale !== null)
+            return `interval day (${numericPrecision}) to second (${numericScale})`;
+        if (numericPrecision !== null)
+            return `interval day (${numericPrecision}) to second`;
+        if (numericScale !== null)
+            return `interval day to second (${numericScale})`;
+        return normalizedDataType;
+    }
+    if (SIZED_DATA_TYPES.has(normalizedDataType)) {
+        if (characterMaximumLength)
+            return `${normalizedDataType}(${characterMaximumLength})`;
+        return normalizedDataType;
+    }
+    if (PRECISION_DATA_TYPES.has(normalizedDataType)) {
+        if (numericPrecision !== null)
+            return `${normalizedDataType}(${numericPrecision})`;
+        return normalizedDataType;
+    }
+    if (PRECISION_SCALED_DATA_TYPES.has(normalizedDataType)) {
+        if (numericPrecision !== null && numericScale !== null)
+            return `${normalizedDataType}(${numericPrecision}, ${numericScale})`;
+        if (numericPrecision !== null)
+            return `${normalizedDataType}(${numericPrecision})`;
+        // There's no situation where numericScale is not null but numericPrecision is null
+        return normalizedDataType;
+    }
+    // This is not needed since we return `normalizedDataType` either if the condition holds true or not
+    // if (UNQUALIFIED_DATA_TYPES.has(normalizedDataType)) {
+    //   return normalizedDataType;
+    // }
+    return normalizedDataType;
+}
+;

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

@@ -0,0 +1,9 @@
+export declare const LIST_SEPARATOR = "@@@@@@@@";
+export declare const EXECUTE_OPTIONS: {
+    outFormat: number;
+};
+export declare function processEasyConnectString(connection: string): {
+    username: string;
+    password: string;
+    dbidentifier: string;
+};

package/dist/connectors/oracle/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXECUTE_OPTIONS = exports.LIST_SEPARATOR = void 0;
+exports.processEasyConnectString = processEasyConnectString;
+const oracledb_1 = __importDefault(require("oracledb"));
+exports.LIST_SEPARATOR = '@@@@@@@@'; // Used to join multiple fields into a string field to simulate array column types
+exports.EXECUTE_OPTIONS = { outFormat: oracledb_1.default.OUT_FORMAT_OBJECT };
+// Expect an Easy Connect string format: username/password@[//]host[:port][/database]
+// Explanation of the format: https://www.orafaq.com/wiki/EZCONNECT
+function processEasyConnectString(connection) {
+    // Capturing group `username`: a string without the characters `/` `@` `:`
+    // Capturing group `password`: a string without the characters `/` `@` `:`
+    // Capturing group `dbidentifier`: a string containing the `host[:port][/database]` part
+    const matches = connection.match(/^(?<username>[^/@:]+)\/(?<password>[^/@:]+)@(\/\/)?(?<dbidentifier>.+)$/);
+    const { username, password, dbidentifier } = matches?.groups || {};
+    if (!username || !password || !dbidentifier) {
+        throw new Error('Invalid Easy Connect string. Expect a string of format \'username/password@[//]host[:port][/database]\'');
+    }
+    return {
+        username,
+        password,
+        dbidentifier,
+    };
+}

package/dist/connectors/{snowflakeConnector.d.ts → postgres/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/{postgresConnector.js → postgres/index.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchSchemaJson = void 0;
 const pg_1 = require("pg");
-const parseSchema_1 = require("../utils/parseSchema");
+const parseSchema_1 = require("../../utils/parseSchema");
 const getValidatedClient = async (connection) => {
     const client = new pg_1.Client(connection);
     try {

package/dist/connectors/{postgresConnector.d.ts → snowflake/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/{snowflakeConnector.js → snowflake/index.js}

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchSchemaJson = void 0;
 const snowflake_sdk_1 = __importDefault(require("snowflake-sdk"));
-const parseSchema_1 = require("../utils/parseSchema");
+const parseSchema_1 = require("../../utils/parseSchema");
 const parseConnectionString = (connectionString) => {
     const params = {};
     const regex = /([^;=]+)=([^;]*)/g;

package/dist/connectors/types.d.ts

@@ -96,4 +96,4 @@ interface BigQueryCredentials {
     };
     datasets: string[];
 }
-export { NoteInfo, TypeInfo, DefaultType, DefaultInfo, Field, Table, FieldsDictionary, TableConstraint, TableConstraintsDictionary, RefEndpoint, Ref, EnumValue, Enum, IndexColumn, Index, IndexesDictionary, DatabaseSchema, BigQueryCredentials, CheckConstraintDictionary, };
+export { NoteInfo, TypeInfo, DefaultType, DefaultInfo, Field, Table, FieldsDictionary, TableConstraint, TableConstraintsDictionary, RefEndpoint, Ref, EnumValue, Enum, IndexColumn, Index, IndexesDictionary, DatabaseSchema, BigQueryCredentials, CheckConstraint, CheckConstraintDictionary, };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/connector",
-  "version": "5.2.0",
+  "version": "5.3.1",
   "description": "This package was created to fetch the schema JSON from many kind of databases.",
   "author": "huy.phung.sw@gmail.com",
   "license": "MIT",
@@ -21,6 +21,7 @@
     "@types/lodash": "^4.17.16",
     "@types/mssql": "^9.1.5",
     "@types/node": "^22.2.0",
+    "@types/oracledb": "^6.10.0",
     "@types/pg": "^8.11.6",
     "@typescript-eslint/eslint-plugin": "^8.46.3",
     "@typescript-eslint/parser": "^8.46.3",
@@ -47,11 +48,12 @@
     "lodash": "^4.17.21",
     "mssql": "^11.0.1",
     "mysql2": "^3.11.0",
+    "oracledb": "^6.10.0",
     "pg": "^8.12.0",
-    "snowflake-sdk": "^2.0.3"
+    "snowflake-sdk": "^2.3.3"
   },
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "20d556a6e6baad8a989c730e2afd3b65dedcea89"
+  "gitHead": "54ca4861d608adbfc17c86d840c2e663e9c428f9"
 }

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:

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}

@@ -4,7 +4,7 @@
  * - 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,
@@ -17,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 = [

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]+)?$';
 

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,
+};