@quillsql/node 0.6.6 → 0.6.9

package/src/clients/QuillServerClient.ts

@@ -1,23 +0,0 @@
-import axios from "axios";
-
-/** This client is currently not used but is a good design pratice */
-
-class QuillServerClient {
-  private baseUrl: string;
-  private config: {
-    headers: {
-      Authorization: string;
-    };
-  };
-
-  constructor(privateKey: string) {
-    this.baseUrl = "";
-    this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
-  }
-
-  public async postQuill(route: string, payload: any): Promise<any> {
-    return axios.post(`${this.baseUrl}/${route}`, payload, this.config);
-  }
-}
-
-export default QuillServerClient;

package/src/db/BigQuery.ts

@@ -1,220 +0,0 @@
-import { BigQuery } from "@google-cloud/bigquery";
-import { QuillQueryResults } from "./DatabaseHelper";
-import { capitalize, depluralize } from "../utils/textProcessing";
-
-export interface BigQueryConfig {
-  datasetName: string;
-  projectId: string;
-  credentials: any;
-}
-
-export function formatBigQueryConfig(connectionString: string): BigQueryConfig {
-  const jsonStartIndex = connectionString.indexOf("{");
-  if (jsonStartIndex === -1) {
-    throw new Error("Invalid input string. No JSON data found.");
-  }
-
-  const datasetName = connectionString.substring(0, jsonStartIndex).trim();
-  const jsonString = connectionString.substring(jsonStartIndex);
-
-  try {
-    const serviceAccount = JSON.parse(jsonString);
-
-    // Validate if required fields are present
-    if (!serviceAccount.project_id || !serviceAccount.private_key) {
-      throw new Error(
-        "Invalid service account JSON. Required fields are missing.",
-      );
-    }
-
-    return {
-      datasetName,
-      projectId: serviceAccount.project_id,
-      credentials: serviceAccount,
-    };
-  } catch (error) {
-    throw new Error("Failed to parse JSON string: " + error);
-  }
-}
-
-export function connectToBigQuery(config: BigQueryConfig) {
-  return new BigQuery(config);
-}
-
-export async function runQueryBigQuery(
-  sql: string,
-  bigQuery: BigQuery,
-): Promise<QuillQueryResults> {
-  const rows = await bigQuery.query(sql);
-  if (!rows[0] || rows[0].length === 0) return { fields: [], rows: [] };
-  const typedRows = rows[0] as { [fieldName: string]: any }[];
-  const fields = Object.keys(typedRows[0]).map((name: string) => ({
-    name,
-    dataTypeID: 1043,
-  }));
-  fields.forEach((field) => {
-    typedRows.some((row) => {
-      if (row[field.name] === null) return false;
-      field.dataTypeID = inferType(row[field.name]);
-      return true;
-    });
-  });
-  return {
-    fields: fields,
-    rows: typedRows,
-  };
-}
-
-export async function getSchemaBigQuery(bigQuery: BigQuery): Promise<string[]> {
-  const [datasets] = await bigQuery.getDatasets();
-  const definedDatasets = datasets.map((dataset) => dataset.id);
-  const filtered: string[] = [];
-  definedDatasets.forEach((dataset) => {
-    if (dataset !== undefined) {
-      filtered.push(dataset);
-    }
-  });
-  return filtered;
-}
-
-export async function getTablesBySchemaBigQuery(
-  bigQuery: BigQuery,
-  schemaNames: string[],
-): Promise<{ tableName: string; schemaName: string }[]> {
-  const allColumns = await Promise.all(
-    schemaNames.map(async (schema) => {
-      const sql = `SELECT table_name FROM ${schema}.INFORMATION_SCHEMA.TABLES WHERE table_type = 'BASE TABLE' OR table_type = 'VIEW' OR table_type = 'MATERIALIZED VIEW'`;
-      const rows = await bigQuery.query(sql);
-      return rows[0].map((row) => {
-        return { tableName: row.table_name, schemaName: schema };
-      });
-    }),
-  );
-  return allColumns.flat();
-}
-
-export async function getColumnsByTableBigQuery(
-  bigQuery: BigQuery,
-  schemaName: string,
-  tableName: string,
-): Promise<string[]> {
-  const sql = `SELECT column_name FROM ${schemaName}.INFORMATION_SCHEMA.COLUMNS WHERE table_name = '${tableName}'`;
-  const rows = await bigQuery.query(sql);
-  return rows[0].map((row: any) => row.column_name);
-}
-
-export async function getForeignKeysBigQuery(
-  connection: BigQuery,
-  schemaName: string,
-  tableName: string,
-  primaryKey: string,
-): Promise<string[]> {
-  const depluralizedTableName = depluralize(tableName);
-  let sql = `SELECT column_name FROM ${schemaName}.INFORMATION_SCHEMA.COLUMNS 
-    WHERE table_name != '${tableName}' 
-    and (column_name = '${primaryKey}' 
-      or column_name = '${depluralizedTableName}_${primaryKey}' 
-      or column_name = '${depluralizedTableName}${capitalize(primaryKey)}')`;
-  const results = await runQueryBigQuery(sql, connection);
-  let foreignKeysString = results.rows.map((key) => {
-    return key.column_name;
-  });
-  foreignKeysString = foreignKeysString.filter(
-    (key) => key !== "id" && key !== "_id_",
-  );
-  foreignKeysString = [...new Set(foreignKeysString)];
-  if (foreignKeysString.length === 0) {
-    sql = `SELECT column_name FROM ${schemaName}.INFORMATION_SCHEMA.COLUMNS 
-      WHERE table_name != '${tableName}' 
-      and (column_name like '${depluralizedTableName}%'
-      or column_name like '%_id' 
-      or column_name like '%Id' 
-      or column_name like '%_${primaryKey}' 
-      or column_name like '%${capitalize(primaryKey)}')`;
-    const results = await runQueryBigQuery(sql, connection);
-    foreignKeysString = results.rows.map((key) => {
-      return key.column_name;
-    });
-    foreignKeysString = [...new Set(foreignKeysString)];
-  }
-  return foreignKeysString;
-}
-
-export async function getSchemaColumnInfoBigQuery(
-  connection: BigQuery,
-  schemaName: string,
-  tableNames: { tableName: string; schemaName: string }[],
-): Promise<
-  { tableName: string; columns: { columnName: string; dataTypeID: number }[] }[]
-> {
-  const allColumns = await Promise.all(
-    tableNames.map(async (tableName) => {
-      const query = `
-      SELECT column_name as columnName, data_type as dataType
-      FROM ${tableName.schemaName}.INFORMATION_SCHEMA.COLUMNS
-      WHERE table_name = '${tableName.tableName}'
-      ORDER BY ordinal_position;
-    `;
-      const results = await runQueryBigQuery(query, connection);
-      return {
-        tableName: `${tableName.schemaName}.${tableName.tableName}`,
-        displayName: `${tableName.schemaName}.${tableName.tableName}`,
-        columns: results.rows.map((row: any) => ({
-          columnName: row.columnName,
-          displayName: row.columnName,
-          dataTypeID: convertBigQueryTypeToPostgresOID(row.dataType),
-          fieldType: row.dataType,
-        })),
-      };
-    }),
-  );
-  return allColumns;
-}
-
-function convertBigQueryTypeToPostgresOID(type: string): number {
-  const typeToOidMap: { [key: string]: number } = {
-    VARCHAR: 1043,
-    INTEGER: 23,
-    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
-}
-
-function inferType(elem: any) {
-  if (typeof elem === "number") {
-    // Check if the number is a float or an integer
-    return Number.isInteger(elem) ? 23 : 700; // 23: integer, 700: real
-  }
-  // BIG QUERY places data into objects as well
-  if (typeof elem === "object") {
-    if (/^\d{4}-\d{2}-\d{2}$/.test(elem.value)) return 1082; // YYYY-MM-DD format
-    if (/^\d{2}\/\d{2}\/\d{2,4}$/.test(elem.value)) return 1082; // MM\DD\YYYY or MM\DD\YY format
-    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?$/.test(elem.value))
-      return 1114; // YYYY-MM-DDTHH:MM:SS[.fraction] format
-    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/.test(elem.value))
-      return 1184; // YYYY-MM-DDTHH:MM:SS[.fraction]Z format
-    if (/^\d{2}:\d{2}:\d{2}$/.test(elem.value)) return 1083; // HH:MM:SS format
-  }
-  if (typeof elem === "string") {
-    // Attempt to infer date, time, and timestamp formats
-    // Date in YYYY-MM-DD format
-    if (/^\d{4}-\d{2}-\d{2}$/.test(elem)) return 1082; // date
-    // Date in MM\DD\YYYY or MM\DD\YY format
-    if (/^\d{2}\/\d{2}\/\d{2,4}$/.test(elem)) return 1082; // date
-    // Timestamp in YYYY-MM-DDTHH:MM:SS[.fraction] format
-    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?$/.test(elem)) return 1114; // timestamp without timezone
-    // Timestamp in YYYY-MM-DDTHH:MM:SS[.fraction]Z format
-    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/.test(elem))
-      return 1184; // timestamp with timezone
-    // Time in HH:MM:SS format
-    if (/^\d{2}:\d{2}:\d{2}$/.test(elem)) return 1083; // time
-    return 1043; // varchar
-  }
-  // Add more specific cases or different data types as needed
-  return 1043; // default or unknown type
-}

package/src/db/CachedConnection.ts

@@ -1,109 +0,0 @@
-import { Mappable, CacheCredentials } from "../models/Cache";
-import { QuillConfig } from "../models/Quill";
-import { createClient } from "redis";
-import { isSuperset, PgError } from "../utils/Error";
-import {
-  DatabaseConnection,
-  connectToDatabase,
-  disconnectFromDatabase,
-  runQueryByDatabase,
-} from "./DatabaseHelper";
-import { PostgresConnectionConfig } from "./Postgres";
-import { SnowflakeConnectionConfig } from "./Snowflake";
-import { BigQueryConfig } from "./BigQuery";
-import { MysqlConnectionConfig } from "./Mysql";
-
-/** The TTL for new cache entries (default: 1h) */
-const DEFAULT_CACHE_TTL = 24 * 60 * 60;
-
-export class CachedConnection {
-  public databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql";
-  public readonly pool: DatabaseConnection;
-  public orgId: any;
-  public ttl: number;
-  public cache: Mappable | null;
-
-  private _isClosed: boolean = false;
-  public get isClosed(): boolean {
-    return this._isClosed;
-  }
-
-  constructor(
-    databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-    config:
-      | PostgresConnectionConfig
-      | SnowflakeConnectionConfig
-      | BigQueryConfig
-      | MysqlConnectionConfig,
-    cacheConfig: Partial<CacheCredentials> = {},
-  ) {
-    this.databaseType = databaseType;
-    this.pool = connectToDatabase(databaseType, config);
-    this.ttl = cacheConfig?.ttl ?? DEFAULT_CACHE_TTL;
-    this.cache = this.getCache(cacheConfig);
-  }
-
-  public async query(text: string): Promise<any> {
-    try {
-      if (this.isClosed) {
-        throw new Error("Connection is closed");
-      }
-      if (!this.cache) {
-        return await runQueryByDatabase(this.databaseType, this.pool, text);
-      }
-      const key: string = `${this.orgId}:${text}`;
-      const cachedResult: string | null = await this.cache.get(key);
-      if (cachedResult) {
-        return JSON.parse(cachedResult);
-      } else {
-        const newResult = await runQueryByDatabase(
-          this.databaseType,
-          this.pool,
-          text,
-        );
-        const newResultString: string = JSON.stringify(newResult);
-        await this.cache.set(key, newResultString, "EX", DEFAULT_CACHE_TTL);
-        return newResult;
-      }
-    } catch (err) {
-      if (isSuperset(err, PgError)) {
-        throw new PgError(
-          (err as any).message,
-          (err as any).detail,
-          (err as any).hint,
-          (err as any).position,
-        );
-      } else if (err instanceof Error) {
-        throw new Error(err.message);
-      }
-    }
-  }
-
-  /**
-   * Configures and returns a cache instance or null if none could be created.
-   */
-  private getCache({
-    username,
-    password,
-    host,
-    port,
-    cacheType,
-  }: QuillConfig["cache"]): Mappable | null {
-    if (cacheType === "redis" || cacheType === "rediss") {
-      const redisURL = `${cacheType}://${username}:${password}@${host}:${port}`;
-      const client = createClient({ url: redisURL });
-      client.connect();
-      return client as Mappable;
-    }
-    return null;
-  }
-
-  public getPool() {
-    return this.pool;
-  }
-
-  async close() {
-    disconnectFromDatabase(this.databaseType, this.pool);
-    this._isClosed = true;
-  }
-}