@dbml/connector 5.0.0 → 5.2.0

package/dist/connectors/postgresConnector.js

@@ -1,7 +1,6 @@
 "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 getValidatedClient = async (connection) => {
@@ -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,
@@ -241,7 +242,7 @@ const generateRawRefs = async (client, schemas) => {
     });
     return refs;
 };
-const generateIndexes = async (client, schemas) => {
+const generateIndexesAndConstraints = async (client, schemas) => {
     const indexListSql = `
     WITH user_tables AS (
       SELECT
@@ -288,8 +289,8 @@ const generateIndexes = async (client, schemas) => {
       ii.is_unique,
       ii.is_primary,
       ii.index_type,
-      ii.columns,
-      ii.expressions,
+      ii.columns AS index_columns,
+      ii.expressions AS index_expressions,
       ii.constraint_type  -- Retained constraint type here
     FROM
       user_tables ut
@@ -304,34 +305,36 @@ const generateIndexes = async (client, schemas) => {
     ;
   `;
     const indexListResult = await client.query(indexListSql);
-    const { outOfLineConstraints, inlineConstraints } = indexListResult.rows.reduce((acc, row) => {
-        const { constraint_type, columns } = row;
-        if (columns === 'null' || columns.trim() === '')
+    const { outOfLineIndexes, inlineIndexes } = indexListResult.rows.reduce((acc, row) => {
+        const { constraint_type, index_columns } = row;
+        if (index_columns === 'null' || index_columns.trim() === '')
             return acc;
-        const isSingleColumn = columns.split(',').length === 1;
-        const isInlineConstraint = isSingleColumn && (constraint_type === 'PRIMARY KEY' || constraint_type === 'UNIQUE');
-        if (isInlineConstraint) {
-            acc.inlineConstraints.push(row);
+        const isSingleColumn = index_columns.split(',').length === 1;
+        const isInlineIndex = isSingleColumn && (constraint_type === 'PRIMARY KEY' || constraint_type === 'UNIQUE');
+        if (isInlineIndex) {
+            acc.inlineIndexes.push(row);
         }
         else {
-            acc.outOfLineConstraints.push(row);
+            acc.outOfLineIndexes.push(row);
         }
         return acc;
-    }, { outOfLineConstraints: [], inlineConstraints: [] });
-    const indexes = outOfLineConstraints.reduce((acc, indexRow) => {
-        const { table_schema, table_name, index_name, index_type, columns, expressions, } = indexRow;
-        const indexColumns = columns.split(',').map((column) => {
+    }, { outOfLineIndexes: [], inlineIndexes: [] });
+    const indexes = outOfLineIndexes.reduce((acc, 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 = expressions ? 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 generateIndexes = async (client, schemas) => {
                 ...indexColumns,
                 ...indexExpressions,
             ],
+            pk: !!is_primary,
+            unique: !is_primary && !!is_unique,
         };
         const key = `${table_schema}.${table_name}`;
         if (acc[key]) {
@@ -349,27 +354,94 @@ const generateIndexes = async (client, schemas) => {
         }
         return acc;
     }, {});
-    const tableConstraints = inlineConstraints.reduce((acc, row) => {
-        const { table_schema, table_name, columns, constraint_type, } = row;
+    const tableConstraints = {};
+    inlineIndexes.forEach((row) => {
+        const { table_schema, table_name, index_columns, constraint_type, } = row;
         const key = `${table_schema}.${table_name}`;
-        if (!acc[key])
-            acc[key] = {};
-        const columnNames = columns.split(',').map((column) => column.trim());
+        if (!tableConstraints[key])
+            tableConstraints[key] = {};
+        const columnNames = index_columns.split(',').map((column) => column.trim());
         columnNames.forEach((columnName) => {
-            if (!acc[key][columnName])
-                acc[key][columnName] = {};
+            if (!tableConstraints[key][columnName])
+                tableConstraints[key][columnName] = { checks: [] };
             if (constraint_type === 'PRIMARY KEY') {
-                acc[key][columnName].pk = true;
+                tableConstraints[key][columnName].pk = true;
             }
-            if (constraint_type === 'UNIQUE' && !acc[key][columnName].pk) {
-                acc[key][columnName].unique = true;
+            if (constraint_type === 'UNIQUE' && !tableConstraints[key][columnName].pk) {
+                tableConstraints[key][columnName].unique = true;
             }
         });
-        return acc;
     }, {});
+    const checkListSql = `
+    SELECT
+      n.nspname AS table_schema,
+      c.relname AS table_name,
+      MAX(a.attname) AS column_name,
+      con.conname AS check_name,
+      pg_get_constraintdef(con.oid) AS check_definition,
+      CASE
+        WHEN COUNT(*) = 1 THEN TRUE
+        ELSE FALSE
+      END AS is_column_constraint 
+    FROM
+      pg_catalog.pg_constraint AS con
+    JOIN
+      pg_catalog.pg_class AS c
+      ON con.conrelid = c.oid
+    LEFT JOIN
+      pg_catalog.pg_namespace AS n
+      ON c.relnamespace = n.oid
+    LEFT JOIN
+      pg_catalog.pg_attribute AS a
+      ON a.attrelid = c.oid AND a.attnum = ANY(con.conkey)
+    WHERE con.contype = 'c' -- 'c' for CHECK constraints
+    ${(0, parseSchema_1.buildSchemaQuery)('n.nspname', schemas)}
+    GROUP BY
+      con.conname,
+      n.nspname,
+      c.relname,
+      con.oid
+  `;
+    const checkListResult = await client.query(checkListSql);
+    const checks = {};
+    checkListResult.rows.forEach((row) => {
+        const { table_schema, table_name, check_name, check_definition, column_name, is_column_constraint, } = row;
+        if (typeof table_schema !== 'string' || typeof table_name !== 'string' || typeof check_definition !== 'string') {
+            return;
+        }
+        if (!check_definition.match(/CHECK \(\(.*\)\)/)) {
+            return;
+        }
+        if (is_column_constraint && typeof column_name !== 'string') {
+            return;
+        }
+        const key = `${table_schema}.${table_name}`;
+        if (is_column_constraint) {
+            if (!tableConstraints[key])
+                tableConstraints[key] = {};
+            if (!tableConstraints[key][column_name])
+                tableConstraints[key][column_name] = { checks: [] };
+            tableConstraints[key][column_name].checks.push({
+                name: check_name || undefined,
+                // The check definition has the form: `CHECK ((expr))`
+                // The expression starts at 8 and ends at -2
+                expression: check_definition.slice(8, -2),
+            });
+            return;
+        }
+        if (!checks[key])
+            checks[key] = [];
+        checks[key].push({
+            name: check_name || undefined,
+            // The check definition has the form: `CHECK ((expr))`
+            // The expression starts at 8 and ends at -2
+            expression: check_definition.slice(8, -2),
+        });
+    });
     return {
         indexes,
         tableConstraints,
+        checks,
     };
 };
 const generateRawEnums = async (client, schemas) => {
@@ -414,7 +486,7 @@ const fetchSchemaJson = async (connection) => {
     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 indexesRes = generateIndexesAndConstraints(client, schemas);
     const refsRes = generateRawRefs(client, schemas);
     const enumsRes = generateRawEnums(client, schemas);
     const res = await Promise.all([
@@ -425,7 +497,7 @@ const fetchSchemaJson = async (connection) => {
     ]);
     client.end();
     const { tables, fields } = res[0];
-    const { indexes, tableConstraints } = res[1];
+    const { indexes, tableConstraints, checks } = res[1];
     const refs = res[2];
     const enums = res[3];
     return {
@@ -435,6 +507,7 @@ const fetchSchemaJson = async (connection) => {
         enums,
         indexes,
         tableConstraints,
+        checks,
     };
 };
 exports.fetchSchemaJson = fetchSchemaJson;

package/dist/connectors/snowflakeConnector.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable camelcase */
 //
 // Description:
 // Snowflake info schema lacks reference direction for relationships.
@@ -40,7 +39,7 @@ const executeQuery = (connection, sqlText) => {
     return new Promise((resolve, reject) => {
         console.log('Executing query...');
         connection.execute({
-            sqlText: sqlText,
+            sqlText,
             complete: (err, stmt, rows) => {
                 if (err) {
                     reject(err);
@@ -51,7 +50,7 @@ const executeQuery = (connection, sqlText) => {
                         resolve(rows);
                     }
                 }
-            }
+            },
         });
     });
 };
@@ -203,14 +202,14 @@ const generateTablesAndFields = async (conn, schemas) => {
 };
 const createConstraintKeysMap = (keys, schemas, constraintType) => {
     return keys.reduce((acc, row) => {
-        const { schema_name, table_name, column_name, constraint_name } = row;
+        const { schema_name, table_name, column_name, constraint_name, } = row;
         const selectedSchema = schemas.length > 0 ? schemas.includes(schema_name) : true;
         if (!selectedSchema) {
             return acc;
         }
         const key = `${schema_name}.${table_name}.${constraint_name}`;
         if (acc[key]) {
-            const columnNames = acc[key].columnNames;
+            const { columnNames } = acc[key];
             columnNames.push(column_name);
             return acc;
         }
@@ -238,13 +237,14 @@ const generateIndexes = async (conn, databaseName, schemas) => {
     const uniqueKeysByConstraint = createConstraintKeysMap(uniqueKeys, schemas, 'unique');
     const allConstraints = [Object.values(primaryKeysByConstraint), Object.values(uniqueKeysByConstraint)].flat();
     const { indexes, tableConstraints } = allConstraints.reduce((acc, row) => {
-        const { schemaName, tableName, constraintName, columnNames, type, primary, unique } = row;
+        const { schemaName, tableName, constraintName, columnNames, type, primary, unique, } = row;
         const key = `${schemaName}.${tableName}`;
         if (columnNames.length < 2) {
             acc.tableConstraints[key] = {
                 [columnNames[0]]: {
                     pk: primary,
                     unique,
+                    checks: [],
                 },
             };
             return acc;
@@ -304,6 +304,8 @@ const fetchSchemaJson = async (connection) => {
         enums: [],
         indexes,
         tableConstraints,
+        // Checks are not supported in snowflake
+        checks: {},
     };
 };
 exports.fetchSchemaJson = fetchSchemaJson;

package/dist/connectors/types.d.ts

@@ -28,10 +28,18 @@ interface Table {
 interface FieldsDictionary {
     [key: string]: Field[];
 }
+interface CheckConstraint {
+    name?: string;
+    expression: string;
+}
+interface CheckConstraintDictionary {
+    [tableName: string]: CheckConstraint[];
+}
 interface TableConstraint {
     [fieldName: string]: {
         pk?: boolean;
         unique?: boolean;
+        checks: CheckConstraint[];
     };
 }
 interface TableConstraintsDictionary {
@@ -78,6 +86,7 @@ interface DatabaseSchema {
     tableConstraints: TableConstraintsDictionary;
     refs: Ref[];
     indexes: IndexesDictionary;
+    checks: CheckConstraintDictionary;
 }
 interface BigQueryCredentials {
     projectId?: string;
@@ -87,9 +96,4 @@ interface BigQueryCredentials {
     };
     datasets: string[];
 }
-interface EnumValuesDict {
-    columns: string[];
-    enumValues: EnumValue[];
-    constraint_name: string;
-}
-export { NoteInfo, TypeInfo, DefaultType, DefaultInfo, Field, Table, FieldsDictionary, TableConstraint, TableConstraintsDictionary, RefEndpoint, Ref, EnumValue, Enum, IndexColumn, Index, IndexesDictionary, DatabaseSchema, BigQueryCredentials, EnumValuesDict, };
+export { NoteInfo, TypeInfo, DefaultType, DefaultInfo, Field, Table, FieldsDictionary, TableConstraint, TableConstraintsDictionary, RefEndpoint, Ref, EnumValue, Enum, IndexColumn, Index, IndexesDictionary, DatabaseSchema, BigQueryCredentials, 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/helpers.d.ts

@@ -1,7 +1,8 @@
-import { FieldsDictionary, IndexesDictionary, Table, TableConstraintsDictionary } from '../connectors/types';
+import { CheckConstraintDictionary, FieldsDictionary, IndexesDictionary, Table, TableConstraintsDictionary } from '../connectors/types';
 export declare function getIntersection<T>(firstList: T[], secondList: T[]): T[];
 export declare function getTableSchemaKey(schemaName: string, tableName: string): string;
 export declare function mergeTables(firstTableList: Table[], secondTable: Table[]): Table[];
 export declare function mergeFieldDictionary(firstDict: FieldsDictionary, secondDict: FieldsDictionary): FieldsDictionary;
 export declare function mergeIndexDictionary(firstDict: IndexesDictionary, secondDict: IndexesDictionary): IndexesDictionary;
 export declare function mergeTableConstraintDictionary(firstDict: TableConstraintsDictionary, secondDict: TableConstraintsDictionary): TableConstraintsDictionary;
+export declare function mergeCheckConstraintDictionary(firstDict: CheckConstraintDictionary, secondDict: CheckConstraintDictionary): CheckConstraintDictionary;

package/dist/utils/helpers.js

@@ -6,6 +6,7 @@ exports.mergeTables = mergeTables;
 exports.mergeFieldDictionary = mergeFieldDictionary;
 exports.mergeIndexDictionary = mergeIndexDictionary;
 exports.mergeTableConstraintDictionary = mergeTableConstraintDictionary;
+exports.mergeCheckConstraintDictionary = mergeCheckConstraintDictionary;
 function getIntersection(firstList, secondList) {
     return firstList.filter((item) => secondList.includes(item));
 }
@@ -19,7 +20,7 @@ function mergeTables(firstTableList, secondTable) {
     return firstTableList.concat(secondTable);
 }
 function mergeFieldDictionary(firstDict, secondDict) {
-    const result = Object.assign({}, firstDict);
+    const result = { ...firstDict };
     Object.keys(secondDict).forEach((key) => {
         if (!result[key]) {
             result[key] = [];
@@ -29,7 +30,7 @@ function mergeFieldDictionary(firstDict, secondDict) {
     return result;
 }
 function mergeIndexDictionary(firstDict, secondDict) {
-    const result = Object.assign({}, firstDict);
+    const result = { ...firstDict };
     Object.keys(secondDict).forEach((key) => {
         if (!result[key]) {
             result[key] = [];
@@ -39,7 +40,7 @@ function mergeIndexDictionary(firstDict, secondDict) {
     return result;
 }
 function mergeTableConstraintDictionary(firstDict, secondDict) {
-    const result = Object.assign({}, firstDict);
+    const result = { ...firstDict };
     Object.keys(secondDict).forEach((key) => {
         if (!result[key]) {
             result[key] = {};
@@ -48,3 +49,13 @@ function mergeTableConstraintDictionary(firstDict, secondDict) {
     });
     return result;
 }
+function mergeCheckConstraintDictionary(firstDict, secondDict) {
+    const result = { ...firstDict };
+    Object.keys(secondDict).forEach((key) => {
+        if (!result[key]) {
+            result[key] = [];
+        }
+        result[key] = result[key].concat(secondDict[key]);
+    });
+    return result;
+}

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.0.0",
+  "version": "5.2.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,26 +16,34 @@
     "@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/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",
@@ -44,5 +53,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "a2d029e9c3c78ab0956312495165ec3115b5bc00"
+  "gitHead": "20d556a6e6baad8a989c730e2afd3b65dedcea89"
 }