@quillsql/node 0.4.2 → 0.4.3

package/dist/assets/pgtypes.d.ts

@@ -0,0 +1,4 @@
+export declare const PG_TYPES: {
+    typname: string;
+    oid: number;
+}[];

package/dist/clients/QuillServerClient.d.ts

@@ -0,0 +1,8 @@
+/** This client is currently not used but is a good design pratice */
+declare class QuillServerClient {
+    private baseUrl;
+    private config;
+    constructor(privateKey: string);
+    postQuill(route: string, payload: any): Promise<any>;
+}
+export default QuillServerClient;

package/dist/db/BigQuery.d.ts

@@ -0,0 +1,27 @@
+import { BigQuery } from "@google-cloud/bigquery";
+import { QuillQueryResults } from "./DatabaseHelper";
+export interface BigQueryConfig {
+    datasetName: string;
+    projectId: string;
+    credentials: any;
+}
+export declare function formatBigQueryConfig(connectionString: string): BigQueryConfig;
+export declare function connectToBigQuery(config: BigQueryConfig): BigQuery;
+export declare function runQueryBigQuery(sql: string, bigQuery: BigQuery): Promise<QuillQueryResults>;
+export declare function getSchemaBigQuery(bigQuery: BigQuery): Promise<string[]>;
+export declare function getTablesBySchemaBigQuery(bigQuery: BigQuery, schemaNames: string[]): Promise<{
+    tableName: string;
+    schemaName: string;
+}[]>;
+export declare function getColumnsByTableBigQuery(bigQuery: BigQuery, schemaName: string, tableName: string): Promise<string[]>;
+export declare function getForeignKeysBigQuery(connection: BigQuery, schemaName: string, tableName: string, primaryKey: string): Promise<string[]>;
+export declare function getSchemaColumnInfoBigQuery(connection: BigQuery, schemaName: string, tableNames: {
+    tableName: string;
+    schemaName: string;
+}[]): Promise<{
+    tableName: string;
+    columns: {
+        columnName: string;
+        dataTypeID: number;
+    }[];
+}[]>;

package/dist/db/CachedConnection.d.ts

@@ -0,0 +1,16 @@
+import { Mapable, CacheCredentials } from "../models/Cache";
+import { DatabaseConnection, DatabaseType } from "./DatabaseHelper";
+export declare class CachedConnection {
+    databaseType: DatabaseType;
+    pool: DatabaseConnection;
+    orgId: any;
+    ttl: number;
+    cache: Mapable | null;
+    constructor(databaseType: DatabaseType, config: any, cacheConfig?: Partial<CacheCredentials>);
+    query(text: string, values?: any[]): Promise<any>;
+    /**
+     * Configures and returns a cache instance or null if none could be created.
+     */
+    private getCache;
+    close(): Promise<void>;
+}

package/dist/db/DatabaseHelper.d.ts

@@ -0,0 +1,55 @@
+import { Pool } from "pg";
+import snowflake from "snowflake-sdk";
+import { Pool as MysqlPool } from "mysql2";
+import { BigQuery } from "@google-cloud/bigquery";
+import { PostgresConnectionConfig } from "./Postgres";
+import { SnowflakeConnectionConfig } from "./Snowflake";
+import { BigQueryConfig } from "./BigQuery";
+import { MysqlConnectionConfig } from "./Mysql";
+export declare enum DatabaseType {
+    postgres = "postgres",
+    postgresql = "postgresql",
+    snowflake = "snowflake",
+    bigquery = "bigquery",
+    mysql = "mysql"
+}
+export type DatabaseConnection = Pool | snowflake.Connection | BigQuery | MysqlPool;
+export interface QuillQueryResults {
+    fields: {
+        name: string;
+        dataTypeID: number;
+    }[];
+    rows: {
+        [fieldName: string]: any;
+    }[];
+}
+export declare function getDatabaseCredentials(databaseType: DatabaseType, connectionString: string): PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig | undefined;
+export declare function connectToDatabase(databaseType: DatabaseType, config: PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig): DatabaseConnection;
+export declare function runQueryByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, sql: string): Promise<QuillQueryResults> | undefined;
+export declare function disconnectFromDatabase(databaseType: DatabaseType, database: DatabaseConnection): void | Promise<void>;
+export declare function getSchemasByDatabase(databaseType: DatabaseType, connection: DatabaseConnection): Promise<string[] | undefined>;
+export declare function getTablesBySchemaByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, schemaName: string | string[]): Promise<string[] | {
+    tableName: string;
+    schemaName: string;
+}[] | undefined>;
+export declare function getColumnsByTableByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, schemaName: string, tableName: string): Promise<string[] | undefined>;
+export declare function getForiegnKeysByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, schemaName: string, tableName: string, primaryKey: string): Promise<string[] | undefined>;
+export declare function getColumnInfoBySchemaByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, schemaName: string, tables: string[] | {
+    tableName: string;
+    schemaName: string;
+}[]): Promise<{
+    tableName: string;
+    columns: {
+        columnName: string;
+        dataTypeID: number;
+    }[];
+}[]> | Promise<{
+    tableName: string;
+    displayName: string;
+    columns: {
+        columnName: any;
+        displayName: any;
+        dataTypeID: number;
+        fieldType: any;
+    }[];
+}[]> | undefined;

package/dist/db/Mysql.d.ts

@@ -0,0 +1,29 @@
+import { Pool as MysqlPool } from "mysql2";
+import { QuillQueryResults } from "./DatabaseHelper";
+export interface MysqlConnectionConfig {
+    host: string;
+    user: string;
+    password: string;
+    database: string;
+}
+export declare function formatMysqlConfig(connectionString: string): MysqlConnectionConfig;
+export declare function connectToMysql(config: MysqlConnectionConfig): MysqlPool;
+export declare function disconnectFromMysql(connection: MysqlPool): void;
+export declare function runQueryMysql(sql: string, connection: MysqlPool): Promise<QuillQueryResults>;
+export declare function getSchemasMysql(connection: MysqlPool): Promise<string[]>;
+export declare function getTablesBySchemaMysql(connection: MysqlPool, schemaNames: string[]): Promise<{
+    tableName: string;
+    schemaName: string;
+}[]>;
+export declare function getColumnsByTableMysql(connection: MysqlPool, schemaName: string, tableName: string): Promise<string[]>;
+export declare function getForeignKeysMysql(connection: MysqlPool, schemaName: string, tableName: string, primaryKey: string): Promise<string[]>;
+export declare function getSchemaColumnInfoMysql(connection: MysqlPool, schemaName: string, tableNames: {
+    tableName: string;
+    schemaName: string;
+}[]): Promise<{
+    tableName: string;
+    columns: {
+        columnName: string;
+        dataTypeID: number;
+    }[];
+}[]>;

package/dist/db/Postgres.d.ts

@@ -0,0 +1,32 @@
+import { Pool } from "pg";
+import { QuillQueryResults } from "./DatabaseHelper";
+export type PostgresConnectionConfig = {
+    connectionString: string;
+    ssl?: {
+        rejectUnauthorized: false;
+        ca?: string;
+        key?: string;
+        cert?: string;
+    };
+};
+export declare function connectToPostgres(config: PostgresConnectionConfig): Pool;
+export declare function disconnectFromPostgres(pool: Pool): void;
+export declare function runQueryPostgres(sql: string, pool: Pool): Promise<QuillQueryResults>;
+export declare function getSchemasPostgres(pool: Pool): Promise<string[]>;
+export declare function getTablesBySchemaPostgres(pool: Pool, schemaNames: string[]): Promise<{
+    tableName: string;
+    schemaName: string;
+}[]>;
+export declare function getColumnsByTablePostgres(pool: Pool, schemaName: string, tableName: string): Promise<string[]>;
+export declare function getForeignKeysPostgres(pool: Pool, schemaName: string, tableName: string, primaryKey: string): Promise<string[]>;
+export declare function getSchemaColumnInfoPostgress(pool: Pool, schemaName: string, tableNames: {
+    tableName: string;
+    schemaName: string;
+}[]): Promise<{
+    tableName: string;
+    columns: {
+        columnName: string;
+        dataTypeID: number;
+    }[];
+}[]>;
+export declare function formatPostgresConfig(connectionString: string): PostgresConnectionConfig;

package/dist/db/Snowflake.d.ts

@@ -0,0 +1,33 @@
+import snowflake from "snowflake-sdk";
+import { QuillQueryResults } from "./DatabaseHelper";
+export type SnowflakeConnectionConfig = {
+    account: string;
+    username: string;
+    password: string;
+    database: string;
+    warehouse: string;
+};
+export declare function runQuerySnowflake(sql: string, connection: snowflake.Connection): Promise<QuillQueryResults>;
+export declare function getSchemasSnowflake(connection: snowflake.Connection): Promise<string[]>;
+export declare function getTablesBySchemaSnowflake(connection: snowflake.Connection, schemaNames: string[]): Promise<{
+    tableName: string;
+    schemaName: string;
+}[]>;
+export declare function getColumnsByTableSnowflake(connection: snowflake.Connection, schemaName: string, tableName: string): Promise<string[]>;
+export declare function formatSnowflakeConfig(connectionString: string): SnowflakeConnectionConfig;
+export declare function connectToSnowflake(config: SnowflakeConnectionConfig): snowflake.Connection;
+export declare function disconnectFromSnowflake(connection: snowflake.Connection): Promise<void>;
+export declare function getForeignKeysSnowflake(connection: snowflake.Connection, schemaName: string, tableName: string, primaryKey: string): Promise<string[]>;
+export declare function getSchemaColumnInfoSnowflake(connection: snowflake.Connection, schemaName: string, tableNames: {
+    tableName: string;
+    schemaName: string;
+}[]): Promise<{
+    tableName: string;
+    displayName: string;
+    columns: {
+        columnName: any;
+        displayName: any;
+        dataTypeID: number;
+        fieldType: any;
+    }[];
+}[]>;

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { CacheCredentials } from "./models/Cache";
+import { QuillQueryParams } from "./models/Quill";
+import { CachedConnection } from "./db/CachedConnection";
+import "dotenv/config";
+import { DatabaseType } from "./db/DatabaseHelper";
+/**
+ * Quill - Fullstack API Platform for Dashboards and Reporting.
+ */
+export default class QuillClass {
+    targetConnection: CachedConnection;
+    private baseUrl;
+    private config;
+    constructor(privateKey: string, databaseType: DatabaseType, databaseConnectionString?: string, databaseCredentials?: any, cache?: Partial<CacheCredentials>, metadataServerURL?: string);
+    query({ orgId, metadata }: QuillQueryParams): Promise<any>;
+    private runQueries;
+    private postQuill;
+    close(): Promise<void>;
+}

package/dist/index.uspec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/models/Cache.d.ts

@@ -0,0 +1,12 @@
+export interface Mapable {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, type?: string, ttl?: number): Promise<string | null>;
+}
+export interface CacheCredentials {
+    username: string;
+    password: string;
+    host: string;
+    port: string;
+    cacheType: string;
+    ttl?: number;
+}

package/dist/models/Client.d.ts

@@ -0,0 +1,29 @@
+export interface Client {
+    name: string;
+    databaseConnectionString: string;
+    etlDatabaseConnectionString: string;
+    stagingDatabaseConnectionString: string;
+    customerTableTitleFieldName: string;
+    databaseType: string;
+    customerFieldName: string;
+    customerTableFieldName: string;
+    customerTableName: string;
+    customerView: string;
+    customerFieldType: string;
+    useSsl: boolean;
+    serverCa: string;
+    clientCert: string;
+    clientKey: string;
+    defaultQuery: string;
+    ignoreDarkMode: boolean;
+    domainName: string;
+    hideSqlEditor: boolean;
+    adminCustomerId: string;
+    stagingAdminCustomerId: string;
+    cacheCloudConfig: {
+        type: {
+            cacheQueries: boolean;
+        };
+        default: null;
+    };
+}

package/dist/models/Database.d.ts

@@ -0,0 +1,5 @@
+export interface DatabaseCredentials {
+    databaseConnectionString: string;
+    stagingDatabaseConnectionString: string;
+    databaseType: string;
+}

package/dist/models/Formats.d.ts

@@ -0,0 +1,7 @@
+export type FieldFormat = "whole_number" | "one_decimal_place" | "two_decimal_places" | "dollar_amount" | "MMM_yyyy" | "MMM_dd_yyyy" | "MMM_dd-MMM_dd" | "MMM_dd_hh:mm_ap_pm" | "hh_ap_pm" | "percent" | "string";
+export interface FormattedColumn {
+    label: string;
+    field: string;
+    chartType: string;
+    format: FieldFormat;
+}

package/dist/models/Quill.d.ts

@@ -0,0 +1,70 @@
+import { CacheCredentials } from "./Cache";
+import { DatabaseCredentials } from "./Database";
+import { FieldFormat, FormattedColumn } from "./Formats";
+export interface QuillRequestMetadata {
+    task: string;
+    queries?: string[];
+    preQueries?: string[];
+    runQueryConfig?: AdditionalProcessing;
+    query?: string;
+    id?: string;
+    filters?: any[];
+    name?: string;
+    xAxisField?: string;
+    yAxisFields?: FormattedColumn[];
+    xAxisLabel?: string;
+    xAxisFormat?: FieldFormat;
+    yAxisLabel?: string;
+    chartType?: string;
+    dashboardName?: string;
+    columns?: FormattedColumn[];
+    dateField?: {
+        table: string;
+        field: string;
+    };
+    template?: boolean;
+    clientId?: string;
+    deleted?: boolean;
+    databaseType?: string;
+}
+export interface QuillQueryParams {
+    orgId: string;
+    metadata: QuillRequestMetadata;
+    environment?: string;
+}
+export interface QuillConfig {
+    privateKey: string;
+    db: Partial<DatabaseCredentials>;
+    cache: Partial<CacheCredentials>;
+    /**
+     * @deprecated Use db credential object instead
+     */
+    databaseConnectionString?: string;
+    /**
+     * @deprecated Use db credential object instead
+     */
+    stagingDatabaseConnectionString?: string;
+}
+export interface AdditionalProcessing {
+    getSchema?: boolean;
+    getColumns?: boolean;
+    getTables?: boolean;
+    schema?: string;
+    schemaNames?: string[];
+    table?: string;
+    removeFields?: string[];
+    arrayToMap?: {
+        arrayName: string;
+        field: string;
+    };
+    overridePost?: boolean;
+    convertDatatypes?: boolean;
+    limitThousand?: boolean;
+    limitBy?: number;
+}
+export interface QuillClientResponse {
+    queries: string[];
+    metadata: any;
+    runQueryConfig: AdditionalProcessing;
+    error?: string;
+}

package/dist/utils/Error.d.ts

@@ -0,0 +1,7 @@
+export declare class PgError extends Error {
+    code?: string;
+    detail?: string;
+    hint?: string;
+    position?: string;
+}
+export declare function isSuperset(obj: any, baseClass: any): boolean;

package/dist/utils/RunQueryProcesses.d.ts

@@ -0,0 +1,3 @@
+import { CachedConnection } from "../db/CachedConnection";
+export declare function removeFields(queryResults: any, fieldsToRemove: string[]): any;
+export declare function mapQueries(queries: string[], targetConnection: CachedConnection): Promise<any[]>;

package/dist/utils/schemaConversion.d.ts

@@ -0,0 +1 @@
+export declare function convertTypeToPostgres(data_type_id: number): string;

package/dist/utils/textProcessing.d.ts

@@ -0,0 +1,2 @@
+export declare function capitalize(text: string): string;
+export declare function depluralize(text: string): string;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@quillsql/node",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Quill's client SDK for node backends.",
   "main": "dist/index.js",
   "module": "./dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc --outDir dist",
     "start:dev": "nodemon ./examples/node-server/app.ts",

package/tsconfig.json

@@ -6,6 +6,7 @@
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "skipLibCheck": true,
+    "declaration": true,
     "outDir": "./dist",
     "rootDir": "./src"
   },