@dbml/connector 5.1.0 → 5.3.0

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/{postgresConnector.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}

@@ -1,9 +1,8 @@
 "use strict";
 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 parseSchema_1 = require("../../utils/parseSchema");
 const getValidatedClient = async (connection) => {
     const client = new pg_1.Client(connection);
     try {
@@ -63,13 +62,15 @@ const getDbdefault = (data_type, column_default, default_type) => {
 const generateField = (row) => {
     const { column_name, data_type, character_maximum_length, numeric_precision, numeric_scale, udt_schema, udt_name, identity_increment, is_nullable, column_default, default_type, column_comment, } = row;
     const dbdefault = column_default && default_type !== 'increment' ? getDbdefault(data_type, column_default, default_type) : null;
-    const fieldType = data_type === 'USER-DEFINED' ? {
-        type_name: udt_name,
-        schemaName: udt_schema,
-    } : {
-        type_name: getFieldType(data_type, udt_name, character_maximum_length, numeric_precision, numeric_scale),
-        schemaName: null,
-    };
+    const fieldType = data_type === 'USER-DEFINED'
+        ? {
+            type_name: udt_name,
+            schemaName: udt_schema,
+        }
+        : {
+            type_name: getFieldType(data_type, udt_name, character_maximum_length, numeric_precision, numeric_scale),
+            schemaName: null,
+        };
     return {
         name: column_name,
         type: fieldType,
@@ -319,19 +320,21 @@ const generateIndexesAndConstraints = async (client, schemas) => {
         return acc;
     }, { outOfLineIndexes: [], inlineIndexes: [] });
     const indexes = outOfLineIndexes.reduce((acc, indexRow) => {
-        const { table_schema, table_name, index_name, index_type, index_columns, index_expressions, } = indexRow;
+        const { table_schema, table_name, index_name, index_type, index_columns, index_expressions, is_primary, is_unique, } = indexRow;
         const indexColumns = index_columns.split(',').map((column) => {
             return {
                 type: 'column',
                 value: column.trim(),
             };
         });
-        const indexExpressions = index_expressions ? index_expressions.split(',').map((expression) => {
-            return {
-                type: 'expression',
-                value: expression,
-            };
-        }) : [];
+        const indexExpressions = index_expressions
+            ? index_expressions.split(',').map((expression) => {
+                return {
+                    type: 'expression',
+                    value: expression,
+                };
+            })
+            : [];
         const index = {
             name: index_name,
             type: index_type,
@@ -339,6 +342,8 @@ const generateIndexesAndConstraints = async (client, schemas) => {
                 ...indexColumns,
                 ...indexExpressions,
             ],
+            pk: !!is_primary,
+            unique: !is_primary && !!is_unique,
         };
         const key = `${table_schema}.${table_name}`;
         if (acc[key]) {

package/dist/connectors/{mssqlConnector.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}

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable camelcase */
 //
 // Description:
 // Snowflake info schema lacks reference direction for relationships.
@@ -13,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/dist/index.d.ts

@@ -1,2 +1,2 @@
-import * as connector from "./connectors/connector";
+import * as connector from './connectors/connector';
 export { connector, };

package/dist/index.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connector = void 0;
 const connector = __importStar(require("./connectors/connector"));

package/dist/utils/parseSchema.d.ts

@@ -1,3 +1,4 @@
+export declare const parseSchema: (schemas: string | undefined) => string[];
 export declare const parseJdbcSchema: (connectionString: string) => {
     connectionString: string;
     schemas: string[];
@@ -7,4 +8,3 @@ export declare const parseConnectionString: (connectionString: string, connectio
     schemas: string[];
 };
 export declare const buildSchemaQuery: (columnName: string, schemas: string[], prefix?: string) => string;
-export declare const parseSchema: (schemas: string | undefined) => string[];

package/dist/utils/parseSchema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchema = exports.buildSchemaQuery = exports.parseConnectionString = exports.parseJdbcSchema = void 0;
+exports.buildSchemaQuery = exports.parseConnectionString = exports.parseJdbcSchema = exports.parseSchema = void 0;
 // You cannot use the "=" inside database's schema name. It will be treated as a delimiter.
 const SCHEMAS_DELIMITER = 'schemas=';
 const haveSchemas = (str) => {
@@ -13,6 +13,18 @@ const noSchemaResult = (connectionString) => ({
     connectionString,
     schemas: [],
 });
+// Inputs: schemas string -> Output: schema array string[]
+// schema1, schema2 -> ['schema1', 'schema2']
+// schema3,schema4 -> ['schema3", 'schema4']
+// "schema5,gg", "schema6", schema7 -> ['schema5,gg', 'schema6', 'schema7']
+// schema8 -> ['schema8']
+const parseSchema = (schemas) => {
+    if (!schemas)
+        return [];
+    const schemasWithDoubleQuotes = schemas.split(/,(?=(?:[^"]*(?:"[^"]*")*)*$)/).map((s) => s.trim());
+    return schemasWithDoubleQuotes.map((s) => s.replace(/"/g, ''));
+};
+exports.parseSchema = parseSchema;
 const parseOdbcSchema = (connectionString) => {
     const connectionParts = connectionString.split(';');
     const schemasPart = connectionParts.find((part) => haveSchemas(part));
@@ -45,15 +57,3 @@ const buildSchemaQuery = (columnName, schemas, prefix = 'AND') => {
     return `${prefix} ${columnName} IN (${schemas.map((schema) => `'${schema}'`).join(', ')})`;
 };
 exports.buildSchemaQuery = buildSchemaQuery;
-// Inputs: schemas string -> Output: schema array string[]
-// schema1, schema2 -> ['schema1', 'schema2']
-// schema3,schema4 -> ['schema3", 'schema4']
-// "schema5,gg", "schema6", schema7 -> ['schema5,gg', 'schema6', 'schema7']
-// schema8 -> ['schema8']
-const parseSchema = (schemas) => {
-    if (!schemas)
-        return [];
-    const schemasWithDoubleQuotes = schemas.split(/,(?=(?:[^"]*(?:"[^"]*")*)*$)/).map((s) => s.trim());
-    return schemasWithDoubleQuotes.map((s) => s.replace(/"/g, ''));
-};
-exports.parseSchema = parseSchema;

package/eslint.config.ts

@@ -0,0 +1,70 @@
+import eslint from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+import tsparser from '@typescript-eslint/parser';
+import stylistic from '@stylistic/eslint-plugin';
+
+export default defineConfig(
+  eslint.configs.recommended,
+  tseslint.configs.recommended,
+  stylistic.configs.customize({
+    indent: 2,
+    semi: true,
+    arrowParens: true,
+    braceStyle: '1tbs',
+  }),
+  [
+    {
+      ignores: [
+        'node_modules/*',
+        'dist/*',
+        'eslint.config.ts',
+        'jestHelpers.ts',
+        'jest.config.ts',
+        '**/*.test.ts',
+      ],
+    },
+    {
+      files: ['**/*.ts'],
+      languageOptions: {
+        parser: tsparser,
+        parserOptions: {
+          sourceType: 'module',
+          ecmaVersion: 2020,
+          project: './tsconfig.json',
+        },
+      },
+      plugins: {
+        '@stylistic': stylistic,
+      },
+      rules: {
+        '@typescript-eslint/no-explicit-any': 'off',
+        'no-use-before-define': 'off',
+        'no-continue': 'off',
+        'no-useless-escape': 'warn',
+        '@stylistic/space-before-function-paren': ['error', 'always'],
+        '@typescript-eslint/no-unused-vars': [
+          'warn',
+          {
+            argsIgnorePattern: '^_',
+            varsIgnorePattern: '^_',
+            caughtErrorsIgnorePattern: '^_',
+          },
+        ],
+        'consistent-return': 'off',
+        '@typescript-eslint/consistent-return': ['error'],
+        '@stylistic/quotes': ['error', 'single', { 'avoidEscape': true }],
+        '@stylistic/max-statements-per-line': 'off',
+        '@stylistic/operator-linebreak': ['error', 'before', { overrides: { '=': 'after' } }],
+      },
+      settings: {
+        'import/resolver': {
+          typescript: {
+            alwaysTryTypes: true,
+            project: 'packages/*/{ts,js}config.json',
+          },
+        },
+      },
+    },
+  ],
+);

package/jest.config.ts

@@ -2,9 +2,9 @@ module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   transform: {
-    "^.+\\.[tj]sx?$": "babel-jest",
+    '^.+\\.[tj]sx?$': 'babel-jest',
   },
   moduleNameMapper: {
-    "\\.(css|less|scss)$": "identity-obj-proxy",
+    '\\.(css|less|scss)$': 'identity-obj-proxy',
   },
 };

package/package.json

@@ -1,6 +1,7 @@
 {
+  "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/connector",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "description": "This package was created to fetch the schema JSON from many kind of databases.",
   "author": "huy.phung.sw@gmail.com",
   "license": "MIT",
@@ -15,34 +16,44 @@
     "@babel/preset-env": "^7.21.4",
     "@babel/preset-typescript": "^7.24.7",
     "@babel/runtime": "^7.21.0",
+    "@stylistic/eslint-plugin": "^5.5.0",
     "@types/jest": "^29.5.12",
     "@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",
     "babel-jest": "^29.5.0",
+    "eslint": "^9.39.1",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.4",
     "ts-node": "^10.9.2",
-    "typescript": "^5.5.4"
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.3"
   },
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "test": "jest"
+    "test": "jest",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix ."
   },
   "dependencies": {
     "@google-cloud/bigquery": "^7.9.0",
-    "@typescript-eslint/eslint-plugin": "^8.30.1",
-    "@typescript-eslint/parser": "^8.30.1",
+    "@typescript-eslint/eslint-plugin": "^8.46.3",
+    "@typescript-eslint/parser": "^8.46.3",
+    "eslint": "^9.39.1",
     "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"
   },
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "376dca507512a3fe549f630e6f22d7d339939183"
+  "gitHead": "c8e67b627584b81d18c16a6f2983a92d75a326d9"
 }