@quillsql/node 0.5.9 → 0.6.1

package/dist/db/BigQuery.js

@@ -164,6 +164,7 @@ function convertBigQueryTypeToPostgresOID(type) {
         FLOAT: 700,
         TIMESTAMP: 1114,
         DATE: 1082,
+        BOOL: 16,
     };
     const postgresType = typeToOidMap[type.toUpperCase()] || "VARCHAR"; // Default to 'text' if the type is not recognized
     return typeToOidMap[postgresType] || 1043; // Default to OID for 'text' if the type is not recognized

package/dist/db/CachedConnection.d.ts

@@ -1,14 +1,19 @@
-import { Mapable, CacheCredentials } from "../models/Cache";
+import { Mappable, CacheCredentials } from "../models/Cache";
 import { DatabaseConnection } from "./DatabaseHelper";
+import { PostgresConnectionConfig } from "./Postgres";
+import { SnowflakeConnectionConfig } from "./Snowflake";
+import { BigQueryConfig } from "./BigQuery";
+import { MysqlConnectionConfig } from "./Mysql";
 export declare class CachedConnection {
     databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql";
-    pool: DatabaseConnection | null;
+    readonly pool: DatabaseConnection;
     orgId: any;
     ttl: number;
-    cache: Mapable | null;
-    private config;
-    constructor(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", config: any, cacheConfig?: Partial<CacheCredentials>);
-    query(text: string, values?: any[]): Promise<any>;
+    cache: Mappable | null;
+    private _isClosed;
+    get isClosed(): boolean;
+    constructor(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", config: PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig, cacheConfig?: Partial<CacheCredentials>);
+    query(text: string): Promise<any>;
     /**
      * Configures and returns a cache instance or null if none could be created.
      */

package/dist/db/CachedConnection.js

@@ -13,30 +13,26 @@ exports.CachedConnection = void 0;
 const redis_1 = require("redis");
 const Error_1 = require("../utils/Error");
 const DatabaseHelper_1 = require("./DatabaseHelper");
-class PgError extends Error {
-    // Add other properties if needed
-    constructor(detail, hint, position) {
-        super();
-        this.detail = detail;
-        this.hint = hint;
-        this.position = position;
-    }
-}
 /** The TTL for new cache entries (default: 1h) */
 const DEFAULT_CACHE_TTL = 24 * 60 * 60;
 class CachedConnection {
+    get isClosed() {
+        return this._isClosed;
+    }
     constructor(databaseType, config, cacheConfig = {}) {
         var _a;
+        this._isClosed = false;
         this.databaseType = databaseType;
         this.pool = (0, DatabaseHelper_1.connectToDatabase)(databaseType, config);
-        this.config = config;
         this.ttl = (_a = cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.ttl) !== null && _a !== void 0 ? _a : DEFAULT_CACHE_TTL;
         this.cache = this.getCache(cacheConfig);
     }
-    query(text, values) {
+    query(text) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                this.pool = this.getPool();
+                if (this.isClosed) {
+                    throw new Error("Connection is closed");
+                }
                 if (!this.cache) {
                     return yield (0, DatabaseHelper_1.runQueryByDatabase)(this.databaseType, this.pool, text);
                 }
@@ -53,18 +49,13 @@ class CachedConnection {
                 }
             }
             catch (err) {
-                if ((0, Error_1.isSuperset)(err, PgError)) {
-                    throw new PgError(err.detail, err.hint, err.position);
+                if ((0, Error_1.isSuperset)(err, Error_1.PgError)) {
+                    throw new Error_1.PgError(err.message, err.detail, err.hint, err.position);
                 }
                 else if (err instanceof Error) {
                     throw new Error(err.message);
                 }
             }
-            finally {
-                if (this.databaseType.toLowerCase() === "mysql") {
-                    this.close();
-                }
-            }
         });
     }
     /**
@@ -80,17 +71,12 @@ class CachedConnection {
         return null;
     }
     getPool() {
-        if (!this.pool) {
-            this.pool = (0, DatabaseHelper_1.connectToDatabase)(this.databaseType, this.config);
-        }
         return this.pool;
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.pool) {
-                (0, DatabaseHelper_1.disconnectFromDatabase)(this.databaseType, this.pool);
-                this.pool = null;
-            }
+            (0, DatabaseHelper_1.disconnectFromDatabase)(this.databaseType, this.pool);
+            this._isClosed = true;
         });
     }
 }

package/dist/db/DatabaseHelper.d.ts

@@ -16,9 +16,11 @@ export interface QuillQueryResults {
         [fieldName: string]: any;
     }[];
 }
-export declare function getDatabaseCredentials(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connectionString: string): PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig | undefined;
+export declare function getDatabaseCredentials(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connectionString: string): PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig;
 export declare function connectToDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", config: PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig): DatabaseConnection;
+export declare function withConnection<T>(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connectionString: string, callback: (connection: DatabaseConnection) => T): Promise<T>;
 export declare function runQueryByDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connection: DatabaseConnection, sql: string): Promise<QuillQueryResults> | undefined;
+export declare function connectAndRunQuery(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connectionString: string, sql: string): Promise<QuillQueryResults | undefined>;
 export declare function disconnectFromDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", database: DatabaseConnection): void | Promise<void>;
 export declare function getSchemasByDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connection: DatabaseConnection): Promise<string[] | undefined>;
 export declare function getTablesBySchemaByDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connection: DatabaseConnection, schemaName: string | string[]): Promise<string[] | {

package/dist/db/DatabaseHelper.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getColumnInfoBySchemaByDatabase = exports.getForiegnKeysByDatabase = exports.getColumnsByTableByDatabase = exports.getTablesBySchemaByDatabase = exports.getSchemasByDatabase = exports.disconnectFromDatabase = exports.runQueryByDatabase = exports.connectToDatabase = exports.getDatabaseCredentials = void 0;
+exports.getColumnInfoBySchemaByDatabase = exports.getForiegnKeysByDatabase = exports.getColumnsByTableByDatabase = exports.getTablesBySchemaByDatabase = exports.getSchemasByDatabase = exports.disconnectFromDatabase = exports.connectAndRunQuery = exports.runQueryByDatabase = exports.withConnection = exports.connectToDatabase = exports.getDatabaseCredentials = void 0;
 const Postgres_1 = require("./Postgres");
 const Snowflake_1 = require("./Snowflake");
 const BigQuery_1 = require("./BigQuery");
@@ -27,7 +27,7 @@ function getDatabaseCredentials(databaseType, connectionString) {
         case "mysql":
             return (0, Mysql_1.formatMysqlConfig)(connectionString);
         default:
-            return undefined;
+            throw new Error("Invalid database type");
     }
 }
 exports.getDatabaseCredentials = getDatabaseCredentials;
@@ -48,6 +48,19 @@ function connectToDatabase(databaseType, config) {
     }
 }
 exports.connectToDatabase = connectToDatabase;
+function withConnection(databaseType, connectionString, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = getDatabaseCredentials(databaseType, connectionString);
+        const connection = connectToDatabase(databaseType, config);
+        try {
+            return yield callback(connection);
+        }
+        finally {
+            yield disconnectFromDatabase(databaseType, connection);
+        }
+    });
+}
+exports.withConnection = withConnection;
 function runQueryByDatabase(databaseType, connection, sql) {
     switch (databaseType.toLowerCase()) {
         case "postgres":
@@ -65,6 +78,12 @@ function runQueryByDatabase(databaseType, connection, sql) {
     }
 }
 exports.runQueryByDatabase = runQueryByDatabase;
+function connectAndRunQuery(databaseType, connectionString, sql) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return withConnection(databaseType, connectionString, (connection) => __awaiter(this, void 0, void 0, function* () { return yield runQueryByDatabase(databaseType, connection, sql); }));
+    });
+}
+exports.connectAndRunQuery = connectAndRunQuery;
 function disconnectFromDatabase(databaseType, database) {
     switch (databaseType.toLowerCase()) {
         case "postgres":

package/dist/db/Postgres.js

@@ -138,24 +138,31 @@ function formatPostgresConfig(connectionString) {
 }
 exports.formatPostgresConfig = formatPostgresConfig;
 // CURRENTLY UNUSED BUT MAYBE USEFUL IN THE FUTURE
-function getSslConfig(client) {
-    if (!client.useSsl) {
-        return undefined;
-    }
-    if (client.serverCa && client.clientKey && client.clientCert) {
-        return {
-            rejectUnauthorized: false,
-            ca: client.serverCa,
-            key: client.clientKey,
-            cert: client.clientCert,
-        };
-    }
-    if (client.serverCa) {
-        return {
-            rejectUnauthorized: false,
-            ca: client.serverCa,
-        };
-    }
-    // if using ssl with no certificates
-    return { rejectUnauthorized: false };
-}
+// function getSslConfig(client: Client):
+//   | {
+//       rejectUnauthorized: false;
+//       ca?: string;
+//       key?: string;
+//       cert?: string;
+//     }
+//   | undefined {
+//   if (!client.useSsl) {
+//     return undefined;
+//   }
+//   if (client.serverCa && client.clientKey && client.clientCert) {
+//     return {
+//       rejectUnauthorized: false,
+//       ca: client.serverCa,
+//       key: client.clientKey,
+//       cert: client.clientCert,
+//     };
+//   }
+//   if (client.serverCa) {
+//     return {
+//       rejectUnauthorized: false,
+//       ca: client.serverCa,
+//     };
+//   }
+//   // if using ssl with no certificates
+//   return { rejectUnauthorized: false };
+// }

package/dist/db/Snowflake.js

@@ -116,7 +116,7 @@ function connectToSnowflake(config) {
 exports.connectToSnowflake = connectToSnowflake;
 function disconnectFromSnowflake(connection) {
     return __awaiter(this, void 0, void 0, function* () {
-        connection.destroy((err, conn) => {
+        connection.destroy((err) => {
             if (err) {
                 console.error(`Failed to disconnect from Snowflake: ${err.message}`);
             }
@@ -126,7 +126,7 @@ function disconnectFromSnowflake(connection) {
 exports.disconnectFromSnowflake = disconnectFromSnowflake;
 function getForeignKeysSnowflake(connection, schemaName, tableName, primaryKey) {
     return __awaiter(this, void 0, void 0, function* () {
-        let depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
+        const depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
         let sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS 
     WHERE TABLE_SCHEMA = '${schemaName}' 
     AND TABLE_NAME = '${schemaName}' 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
+/// <reference types="node" />
 import { CacheCredentials } from "./models/Cache";
 import { QuillQueryParams } from "./models/Quill";
-import { CachedConnection } from "./db/CachedConnection";
 import "dotenv/config";
 /**
  * Quill - Fullstack API Platform for Dashboards and Reporting.
@@ -20,8 +20,8 @@ export declare enum DatabaseType {
     bigquery = "bigquery",
     mysql = "mysql"
 }
-export declare class Quill {
-    targetConnection: CachedConnection;
+export declare class Quill implements AsyncDisposable {
+    private targetConnection;
     private baseUrl;
     private config;
     constructor(data: {
@@ -35,6 +35,7 @@ export declare class Quill {
     query({ orgId, metadata, }: QuillQueryParams): Promise<QuillQueryResult>;
     private runQueries;
     private postQuill;
+    [Symbol.asyncDispose](): Promise<void>;
     close(): Promise<void>;
 }
 export { QuillQueryParams as QuillRequest } from "./models/Quill";

package/dist/index.ispec.js

@@ -13,6 +13,9 @@
 //       process.env.DB_URL as string
 //     );
 //   });
+// afterEach(async () => {
+//   await quill.close();
+// });
 //   afterAll(() => {
 //     jest.restoreAllMocks();
 //   });

package/dist/index.js

@@ -41,10 +41,13 @@ class Quill {
         this.targetConnection = new CachedConnection_1.CachedConnection(databaseType, credentials, cache || {});
     }
     query({ orgId, metadata, }) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             this.targetConnection.orgId = orgId;
             let responseMetadata = {};
+            if (!metadata.task) {
+                return { error: "Missing task.", status: "error", data: {} };
+            }
             try {
                 const preQueryResults = metadata.preQueries
                     ? yield this.runQueries(metadata.preQueries, this.targetConnection.databaseType, metadata.databaseType, metadata.runQueryConfig)
@@ -57,7 +60,11 @@ class Quill {
                 }
                 const response = yield this.postQuill(metadata.task, Object.assign(Object.assign(Object.assign({}, metadata), preQueryResults), { orgId, viewQuery: metadata.preQueries ? metadata.preQueries[0] : undefined }));
                 if (response.error) {
-                    return { status: "error", error: response.error };
+                    return {
+                        status: "error",
+                        error: response.error,
+                        data: response.metadata || {},
+                    };
                 }
                 // if there is no metadata object in the response, create one
                 if (response.metadata) {
@@ -92,8 +99,8 @@ class Quill {
             catch (err) {
                 return {
                     status: "error",
-                    error: err.message,
-                    data: responseMetadata,
+                    error: (_e = (_d = (_c = err.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.error) !== null && _e !== void 0 ? _e : err.message,
+                    data: responseMetadata || {},
                 };
             }
         });
@@ -152,7 +159,9 @@ class Quill {
                         return Object.assign(Object.assign({}, table), { columns: columns, rows: queryResult.rows });
                     }
                     catch (err) {
-                        return Object.assign(Object.assign({}, table), { error: "Error fetching columns" });
+                        return Object.assign(Object.assign({}, table), { error: err.message
+                                ? `Error fetching columns: ${err.message}`
+                                : "Error fetching columns" });
                     }
                 })));
                 results = Object.assign(Object.assign({}, results), { queryResults });
@@ -169,7 +178,6 @@ class Quill {
             else if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.getTables) {
                 const queryResult = yield (0, DatabaseHelper_1.getTablesBySchemaByDatabase)(this.targetConnection.databaseType, this.targetConnection.getPool(), runQueryConfig.schemaNames || runQueryConfig.schema);
                 const schemaInfo = yield (0, DatabaseHelper_1.getColumnInfoBySchemaByDatabase)(this.targetConnection.databaseType, this.targetConnection.getPool(), runQueryConfig.schema, queryResult);
-                this.targetConnection.close();
                 return schemaInfo;
             }
             else {
@@ -212,6 +220,11 @@ class Quill {
             return response.data;
         });
     }
+    [Symbol.asyncDispose]() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.close();
+        });
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.targetConnection.close();
@@ -231,6 +244,8 @@ const requireQuill = ({ privateKey, databaseConnectionString, databaseConfig, ca
 };
 module.exports = requireQuill;
 module.exports.default = requireQuill;
+module.exports.withConnection = DatabaseHelper_1.withConnection;
+module.exports.connectAndRunQuery = DatabaseHelper_1.connectAndRunQuery;
 module.exports.Quill = Quill;
 module.exports.getTablesBySchemaByDatabase = DatabaseHelper_1.getTablesBySchemaByDatabase;
 module.exports.getDatabaseCredentials = DatabaseHelper_1.getDatabaseCredentials;
@@ -239,6 +254,5 @@ module.exports.getForiegnKeysByDatabase = DatabaseHelper_1.getForiegnKeysByDatab
 module.exports.getSchemasByDatabase = DatabaseHelper_1.getSchemasByDatabase;
 module.exports.getColumnInfoBySchemaByDatabase =
     DatabaseHelper_1.getColumnInfoBySchemaByDatabase;
-module.exports.connectToDatabase = DatabaseHelper_1.connectToDatabase;
 module.exports.runQueryByDatabase = DatabaseHelper_1.runQueryByDatabase;
 module.exports.DatabaseType = DatabaseType;

package/dist/index.uspec.js

@@ -14,6 +14,9 @@
 //     );
 //     quill.targetConnection.query = jest.fn().mockResolvedValue([]);
 //   });
+// afterEach(async () => {
+//   await quill.close();
+// });
 //   describe("query", () => {
 //     it("return nothing when suppling no queries", () => {
 //       const metadata = {

package/dist/models/Cache.d.ts

@@ -1,4 +1,4 @@
-export interface Mapable {
+export interface Mappable {
     get(key: string): Promise<string | null>;
     set(key: string, value: string, type?: string, ttl?: number): Promise<string | null>;
 }

package/dist/utils/Error.d.ts

@@ -3,5 +3,6 @@ export declare class PgError extends Error {
     detail?: string;
     hint?: string;
     position?: string;
+    constructor(message: string, detail?: string, hint?: string, position?: string, code?: string);
 }
 export declare function isSuperset(obj: any, baseClass: any): boolean;

package/dist/utils/Error.js

@@ -2,14 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSuperset = exports.PgError = void 0;
 class PgError extends Error {
+    // Add other properties if needed
+    constructor(message, detail, hint, position, code) {
+        super(message);
+        this.code = code;
+        this.detail = detail;
+        this.hint = hint;
+        this.position = position;
+    }
 }
 exports.PgError = PgError;
 function isSuperset(obj, baseClass) {
-    // Get the property names of the base class
-    const baseProps = Object.getOwnPropertyNames(baseClass.prototype);
+    // Get the property names of the base class instance
+    const baseInstance = new baseClass();
+    const baseProps = Object.keys(baseInstance);
     // Check if the object has all the properties of the base class
     for (const prop of baseProps) {
-        if (!obj.hasOwnProperty(prop)) {
+        if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
             return false;
         }
     }

package/dist/utils/RunQueryProcesses.d.ts

@@ -1,3 +1,9 @@
 import { CachedConnection } from "../db/CachedConnection";
+export interface TableSchemaInfo {
+    fieldType: string;
+    name: string;
+    displayName: string;
+    isVisible: boolean;
+}
 export declare function removeFields(queryResults: any, fieldsToRemove: string[]): any;
 export declare function mapQueries(queries: string[], targetConnection: CachedConnection): Promise<any[]>;

package/eslint.config.mjs

@@ -0,0 +1,16 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+  { files: ["**/*.{js,mjs,cjs,ts,jsx,tsx}"] },
+  { languageOptions: { globals: globals.node } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-require-imports": "off",
+    },
+  },
+];

package/examples/mysql-node/app.ts

@@ -0,0 +1,62 @@
+// Write a simple node server to test the SDK
+
+import express from "express";
+import cors from "cors";
+import requireQuill from "../../src/index";
+
+const app = express();
+const port = 3005;
+
+// postgresqlConfigExample {
+//   connectionString: process.env.DB_URL,
+//   ssl: {
+//     rejectUnauthorized: false,
+//   },
+// };
+
+// bigqueryConfigExample {
+//   projectId: process.env.PROJECT_ID,
+//   credentials: serviceAccount // You need to make the serviceAccount JSON
+// }
+
+// snowflakeConfigExample {
+//   account: process.env.ACCOUNT,
+//   username: process.env.USERNAME,
+//   password: process.env.PASSWORD,
+//   warehouse: process.env.WAREHOUSE,
+//   database: process.env.DATABASE,
+// }
+
+// mysqlConfigExample {
+//   host: process.env.HOST,
+//   user: process.env.USER,
+//   password: process.env.PASSWORD,
+//   database: process.env.DATABASE,
+// }
+
+app.use(cors());
+app.use(express.json());
+
+app.get("/", (req, res) => {
+  res.send("Hello World!");
+});
+
+const quill = requireQuill({
+  privateKey: process.env.MYSQL_PRIVATE_KEY ?? "",
+  databaseConnectionString: process.env.MYSQL_DB_URL ?? "",
+  databaseConfig: {}, // TODO: Add database config
+  databaseType: "mysql",
+});
+
+app.post("/quill", async (req, res) => {
+  const { orgId, metadata } = req.body;
+  const result = await quill.query({
+    orgId: orgId ?? metadata.orgId,
+    metadata,
+  });
+  res.send(result);
+});
+
+app.listen(port, () => {
+  console.log(`Example app listening at http://localhost:${port}`);
+});

package/examples/node-server/app.ts

@@ -34,15 +34,14 @@ const port = 3001;
 // }
 
 const quill = require("../../src/index")({
-  privateKey: process.env.PRIVATE_KEY,
-  databaseConnectionString: process.env.DB_URL,
-  // databaseConfig: {
-  //   connectionString: process.env.DB_URL,
-  //   ssl: {
-  //     rejectUnauthorized: false,
-  //   },
-  // },
-  databaseType: process.env.DB_TYPE,
+  privateKey: process.env.PRIVATE_KEY ?? "",
+  databaseConnectionString: process.env.DB_URL ?? "",
+  databaseConfig: {}, // TODO: Add database config
+  databaseType: process.env.DB_TYPE as
+    | "postgresql"
+    | "snowflake"
+    | "bigquery"
+    | "mysql",
 });
 
 app.use(cors());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/node",
-  "version": "0.5.9",
+  "version": "0.6.1",
   "description": "Quill Server SDK for Node.js",
   "main": "dist/index.js",
   "module": "./dist/index.js",
@@ -8,12 +8,18 @@
   "scripts": {
     "build": "tsc --outDir dist",
     "start:dev": "nodemon ./examples/node-server/app.ts",
+    "mysql:dev": "nodemon ./examples/mysql-node/app.ts",
     "integration-tests": "jest '.*\\.ispec\\.ts$'",
-    "test": "tsc src && jest --detectOpenHandles"
+    "test": "tsc src && jest --detectOpenHandles",
+    "style-check": "prettier --check \"**/*.{ts,tsx,md}\"",
+    "style-fix": "prettier --write \"**/*.{ts,tsx,md}\"",
+    "lint-check": "eslint \"**/*.{ts,tsx}\"",
+    "lint-fix": "eslint '**/*.{ts,tsx}' --fix"
   },
   "author": "lagambino",
   "license": "ISC",
   "devDependencies": {
+    "@eslint/js": "^9.9.0",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.11",
@@ -21,11 +27,18 @@
     "@types/pg": "^8.10.9",
     "@types/snowflake-sdk": "^1.6.20",
     "cors": "^2.8.5",
+    "eslint": "^9.9.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-react": "^7.35.0",
     "express": "^4.18.2",
+    "globals": "^15.9.0",
     "jest": "^29.7.0",
     "nodemon": "^3.0.2",
+    "prettier": "^3.3.3",
     "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.1.0"
   },
   "dependencies": {
     "@google-cloud/bigquery": "^7.4.0",