driftsql 1.0.7 → 1.0.9

package/dist/index.d.mts

@@ -1,7 +1,10 @@
-import { PoolConfig } from 'pg';
 import { Config } from '@libsql/client';
 import { ConnectionOptions } from 'mysql2/promise';
 
+interface PostgresConfig {
+    connectionString: string;
+}
+
 type Drivers = ClientOptions['drivers'];
 declare const inspectDB: (drivers: Drivers) => Promise<never>;
 
@@ -15,11 +18,9 @@ type UnifiedQueryResult<T extends Record<string, any>> = {
     }>;
 };
 interface ClientOptions {
-    url?: string;
-    password?: string;
     drivers?: {
         libsql?: Config;
-        postgres?: PoolConfig;
+        postgres?: PostgresConfig;
         mysql?: ConnectionOptions;
     };
     options?: {
@@ -27,8 +28,7 @@ interface ClientOptions {
     };
 }
 declare class DriftSQLClient<DT> {
-    private client;
-    private pool?;
+    private postgres?;
     private mysqlClient?;
     private libsqlClient?;
     private postgresClient?;
@@ -37,10 +37,6 @@ declare class DriftSQLClient<DT> {
     private convertLibsqlResult;
     readonly inspect: () => Promise<void>;
     query<T extends Record<string, any>>(query: string, args?: (string | number | boolean | null)[]): Promise<UnifiedQueryResult<T>>;
-    status(): Promise<{
-        ok: boolean;
-        ping: number;
-    }>;
     findFirst<K extends keyof DT>(table: K, where?: Partial<DT[K]>): Promise<DT[K] | null>;
     findMany<K extends keyof DT>(table: K, options?: {
         where?: Partial<DT[K]>;
@@ -54,4 +50,4 @@ declare class DriftSQLClient<DT> {
 }
 
 export { DriftSQLClient, inspectDB };
-export type { ClientOptions };
+export type { ClientOptions, UnifiedQueryResult };

package/dist/index.d.ts

@@ -1,7 +1,10 @@
-import { PoolConfig } from 'pg';
 import { Config } from '@libsql/client';
 import { ConnectionOptions } from 'mysql2/promise';
 
+interface PostgresConfig {
+    connectionString: string;
+}
+
 type Drivers = ClientOptions['drivers'];
 declare const inspectDB: (drivers: Drivers) => Promise<never>;
 
@@ -15,11 +18,9 @@ type UnifiedQueryResult<T extends Record<string, any>> = {
     }>;
 };
 interface ClientOptions {
-    url?: string;
-    password?: string;
     drivers?: {
         libsql?: Config;
-        postgres?: PoolConfig;
+        postgres?: PostgresConfig;
         mysql?: ConnectionOptions;
     };
     options?: {
@@ -27,8 +28,7 @@ interface ClientOptions {
     };
 }
 declare class DriftSQLClient<DT> {
-    private client;
-    private pool?;
+    private postgres?;
     private mysqlClient?;
     private libsqlClient?;
     private postgresClient?;
@@ -37,10 +37,6 @@ declare class DriftSQLClient<DT> {
     private convertLibsqlResult;
     readonly inspect: () => Promise<void>;
     query<T extends Record<string, any>>(query: string, args?: (string | number | boolean | null)[]): Promise<UnifiedQueryResult<T>>;
-    status(): Promise<{
-        ok: boolean;
-        ping: number;
-    }>;
     findFirst<K extends keyof DT>(table: K, where?: Partial<DT[K]>): Promise<DT[K] | null>;
     findMany<K extends keyof DT>(table: K, options?: {
         where?: Partial<DT[K]>;
@@ -54,4 +50,4 @@ declare class DriftSQLClient<DT> {
 }
 
 export { DriftSQLClient, inspectDB };
-export type { ClientOptions };
+export type { ClientOptions, UnifiedQueryResult };

package/dist/index.mjs

@@ -1,11 +1,28 @@
 import consola from 'consola';
-import ky from 'ky';
-import { Pool } from 'pg';
 import { createClient } from '@libsql/client';
 import mysql from 'mysql2/promise';
+import postgres from 'postgres';
 import fs from 'node:fs/promises';
 
-const supportedDrivers = ["postgres", "mysql", "libsql"];
+const supportedDrivers = ["postgres", "postgresHTTP", "mysql", "libsql"];
+const withTimeout = (promise, timeoutMs = 3e4) => {
+  return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new Error(`Query timeout after ${timeoutMs}ms`)), timeoutMs))]);
+};
+const retryQuery = async (queryFn, maxRetries = 3, baseDelay = 1e3) => {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await queryFn();
+    } catch (error) {
+      if (attempt === maxRetries) {
+        throw error;
+      }
+      const delay = baseDelay * Math.pow(2, attempt - 1);
+      console.warn(`Query attempt ${attempt} failed, retrying in ${delay}ms...`, error);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw new Error("Max retries exceeded");
+};
 const mapDatabaseTypeToTypeScript = (dataType, isNullable = false, driverType = "postgres") => {
   const nullable = isNullable ? " | null" : "";
   const lowerType = dataType.toLowerCase();
@@ -103,140 +120,177 @@ const inspectDB = async (drivers) => {
   const activeDriver = supportedConfiguredDrivers[0];
   let generatedTypes = "";
   const client = new DriftSQLClient({ drivers });
-  let tablesQuery;
-  let tableSchemaFilter;
-  if (activeDriver === "mysql") {
-    const dbResult = await client.query("SELECT DATABASE() as `database`", []);
-    const currentDatabase = dbResult.rows[0]?.database;
-    if (!currentDatabase) {
-      throw new Error("Could not determine current MySQL database name");
-    }
-    console.log(`Using MySQL database: ${currentDatabase}`);
-    tablesQuery = `SELECT TABLE_NAME as table_name
+  try {
+    let tablesQuery;
+    let tableSchemaFilter;
+    if (activeDriver === "mysql") {
+      const dbResult = await withTimeout(
+        retryQuery(() => client.query("SELECT DATABASE() as `database`", [])),
+        1e4
+      );
+      const currentDatabase = dbResult.rows[0]?.database;
+      if (!currentDatabase) {
+        throw new Error("Could not determine current MySQL database name");
+      }
+      console.log(`Using MySQL database: ${currentDatabase}`);
+      tablesQuery = `SELECT TABLE_NAME as table_name
                    FROM information_schema.tables 
                    WHERE TABLE_SCHEMA = ? 
                    AND TABLE_TYPE = 'BASE TABLE'
                    ORDER BY TABLE_NAME`;
-    tableSchemaFilter = currentDatabase;
-  } else if (activeDriver === "postgres") {
-    tablesQuery = `SELECT table_name 
+      tableSchemaFilter = currentDatabase;
+    } else if (activeDriver === "postgres" || activeDriver === "postgresHTTP") {
+      tablesQuery = `SELECT table_name 
                    FROM information_schema.tables 
                    WHERE table_schema = $1 
                    AND table_type = 'BASE TABLE'
                    ORDER BY table_name`;
-    tableSchemaFilter = "public";
-  } else {
-    tablesQuery = `SELECT name as table_name 
+      tableSchemaFilter = "public";
+    } else {
+      tablesQuery = `SELECT name as table_name 
                    FROM sqlite_master 
                    WHERE type = 'table' 
                    ORDER BY name`;
-    tableSchemaFilter = void 0;
-  }
-  const tables = await client.query(tablesQuery, tableSchemaFilter ? [tableSchemaFilter] : []);
-  console.log("Tables in the database:", tables.rows.map((t) => t.table_name).join(", "));
-  for (const table of tables.rows) {
-    const tableName = table.table_name;
-    console.log(`Inspecting table: ${tableName}`);
-    let columnsQuery;
-    let queryParams;
-    if (activeDriver === "mysql") {
-      columnsQuery = `
-        SELECT 
-          COLUMN_NAME as column_name, 
-          DATA_TYPE as data_type, 
-          IS_NULLABLE as is_nullable,
-          COLUMN_DEFAULT as column_default
-        FROM information_schema.columns 
-        WHERE TABLE_NAME = ? 
-        AND TABLE_SCHEMA = ?
-        ORDER BY ORDINAL_POSITION
-      `;
-      queryParams = [tableName, tableSchemaFilter];
-    } else if (activeDriver === "postgres") {
-      columnsQuery = `
-        SELECT 
-          column_name, 
-          data_type, 
-          is_nullable,
-          column_default
-        FROM information_schema.columns 
-        WHERE table_name = $1 
-        AND table_schema = $2
-        ORDER BY ordinal_position
-      `;
-      queryParams = [tableName, tableSchemaFilter];
-    } else {
-      columnsQuery = `
-        SELECT 
-          name as column_name, 
-          type as data_type, 
-          CASE WHEN "notnull" = 0 THEN 'YES' ELSE 'NO' END as is_nullable,
-          dflt_value as column_default
-        FROM pragma_table_info(?)
-        ORDER BY cid
-      `;
-      queryParams = [tableName];
-    }
-    const columns = await client.query(columnsQuery, queryParams);
-    if (columns.rows.length === 0) {
-      console.log(`No columns found for table: ${tableName}`);
-      continue;
-    }
-    console.log(`Columns in ${tableName}:`, columns.rows.map((c) => `${c.column_name} (${c.data_type}${c.is_nullable === "YES" ? ", nullable" : ""})`).join(", "));
-    const uniqueColumns = /* @__PURE__ */ new Map();
-    columns.rows.forEach((col) => {
-      if (!uniqueColumns.has(col.column_name)) {
-        uniqueColumns.set(col.column_name, col);
-      }
-    });
-    generatedTypes += `export interface ${tableName.charAt(0).toUpperCase() + tableName.slice(1)} {
+      tableSchemaFilter = void 0;
+    }
+    const tables = await withTimeout(
+      retryQuery(() => client.query(tablesQuery, tableSchemaFilter ? [tableSchemaFilter] : [])),
+      3e4
+    );
+    console.log("Tables in the database:", tables.rows.map((t) => t.table_name).join(", "));
+    let processedTables = 0;
+    const totalTables = tables.rows.length;
+    for (const table of tables.rows) {
+      const tableName = table.table_name;
+      processedTables++;
+      console.log(`[${processedTables}/${totalTables}] Inspecting table: ${tableName}`);
+      try {
+        let columnsQuery;
+        let queryParams;
+        if (activeDriver === "mysql") {
+          columnsQuery = `
+          SELECT 
+            COLUMN_NAME as column_name, 
+            DATA_TYPE as data_type, 
+            IS_NULLABLE as is_nullable,
+            COLUMN_DEFAULT as column_default
+          FROM information_schema.columns 
+          WHERE TABLE_NAME = ? 
+          AND TABLE_SCHEMA = ?
+          ORDER BY ORDINAL_POSITION
+        `;
+          queryParams = [tableName, tableSchemaFilter];
+        } else if (activeDriver === "postgres" || activeDriver === "postgresHTTP") {
+          columnsQuery = `
+          SELECT 
+            column_name, 
+            data_type, 
+            is_nullable,
+            column_default
+          FROM information_schema.columns 
+          WHERE table_name = $1 
+          AND table_schema = $2
+          ORDER BY ordinal_position
+        `;
+          queryParams = [tableName, tableSchemaFilter];
+        } else {
+          columnsQuery = `
+          SELECT 
+            name as column_name, 
+            type as data_type, 
+            CASE WHEN "notnull" = 0 THEN 'YES' ELSE 'NO' END as is_nullable,
+            dflt_value as column_default
+          FROM pragma_table_info(?)
+          ORDER BY cid
+        `;
+          queryParams = [tableName];
+        }
+        const columns = await withTimeout(
+          retryQuery(
+            () => client.query(columnsQuery, queryParams)
+          ),
+          15e3
+          // Shorter timeout for individual table queries
+        );
+        if (columns.rows.length === 0) {
+          console.log(`No columns found for table: ${tableName}`);
+          continue;
+        }
+        console.log(`Columns in ${tableName}:`, columns.rows.map((c) => `${c.column_name} (${c.data_type}${c.is_nullable === "YES" ? ", nullable" : ""})`).join(", "));
+        const uniqueColumns = /* @__PURE__ */ new Map();
+        columns.rows.forEach((col) => {
+          if (!uniqueColumns.has(col.column_name)) {
+            uniqueColumns.set(col.column_name, col);
+          }
+        });
+        generatedTypes += `export interface ${tableName.charAt(0).toUpperCase() + tableName.slice(1)} {
 `;
-    for (const col of uniqueColumns.values()) {
-      const tsType = mapDatabaseTypeToTypeScript(col.data_type, col.is_nullable === "YES", activeDriver);
-      generatedTypes += `  ${col.column_name}: ${tsType};
+        for (const col of uniqueColumns.values()) {
+          const tsType = mapDatabaseTypeToTypeScript(col.data_type, col.is_nullable === "YES", activeDriver);
+          generatedTypes += `  ${col.column_name}: ${tsType};
 `;
+        }
+        generatedTypes += "}\n\n";
+      } catch (error) {
+        console.error(`Failed to process table ${tableName}:`, error);
+        console.log(`Skipping table ${tableName} and continuing...`);
+        continue;
+      }
     }
-    generatedTypes += "}\n\n";
-  }
-  generatedTypes += "export interface Database {\n";
-  for (const table of tables.rows) {
-    const tableName = table.table_name.charAt(0).toUpperCase() + table.table_name.slice(1);
-    generatedTypes += `  ${tableName}: ${tableName};
+    generatedTypes += "export interface Database {\n";
+    for (const table of tables.rows) {
+      const tableName = table.table_name.charAt(0).toUpperCase() + table.table_name.slice(1);
+      generatedTypes += `  ${tableName}: ${tableName};
 `;
+    }
+    generatedTypes += "}\n\n";
+    await fs.writeFile("db-types.ts", generatedTypes, "utf8");
+    console.log("TypeScript types written to db-types.ts");
+    console.log(`Successfully processed ${processedTables} tables`);
+  } catch (error) {
+    console.error("Fatal error during database inspection:", error);
+    process.exit(1);
   }
-  generatedTypes += "}\n\n";
-  await fs.writeFile("db-types.ts", generatedTypes, "utf8");
-  console.log("TypeScript types written to db-types.ts");
   process.exit(0);
 };
 
-class DriftSQLClient {
+class PostgresDriver {
+  constructor(options) {
+    this.options = options;
+    this.client = postgres(this.options.connectionString);
+  }
   client;
-  pool;
+  async query(query, params) {
+    try {
+      const result = await this.client.unsafe(query, params);
+      return {
+        rows: result,
+        rowCount: result.length,
+        command: void 0
+      };
+    } catch (error) {
+      console.error("Postgres query error:", error);
+      throw error;
+    }
+  }
+  async close() {
+    try {
+      await this.client.end();
+    } catch (error) {
+      console.error("Error closing Postgres client:", error);
+      throw error;
+    }
+  }
+}
+
+class DriftSQLClient {
+  postgres;
   mysqlClient;
   libsqlClient;
   postgresClient;
   drivers;
   constructor(options) {
-    this.client = ky.create({
-      prefixUrl: options.url,
-      headers: {
-        Authorization: `Bearer ${options.password}`
-      },
-      timeout: options.options?.defaultTimeout || 5e3,
-      hooks: {
-        afterResponse: [
-          async (request, options2, response) => {
-            if (!response.ok) {
-              const errorText = await response.text();
-              throw new Error(`HTTP Error: ${response.status} - ${errorText}`);
-            }
-            return response;
-          }
-        ]
-      }
-    });
-    this.pool = options.drivers?.postgres ? new Pool(options.drivers.postgres) : void 0;
+    this.postgres = options.drivers?.postgres ? new PostgresDriver({ connectionString: options.drivers.postgres.connectionString }) : void 0;
     this.libsqlClient = options.drivers?.libsql ? createClient(options.drivers.libsql) : void 0;
     this.mysqlClient = options.drivers?.mysql ? mysql.createConnection(options.drivers.mysql) : void 0;
     this.drivers = options.drivers || {};
@@ -262,22 +316,22 @@ class DriftSQLClient {
   async query(query, args) {
     const driversCount = Object.keys(this.drivers).filter((key) => this.drivers[key] !== void 0).length;
     if (driversCount > 1) {
-      const error = new Error("Multiple drivers are configured. Please use only one driver at a time.");
-      consola.error(error);
-      throw error;
+      const error2 = new Error("Multiple drivers are configured. Please use only one driver at a time.");
+      consola.error(error2);
+      throw error2;
     }
-    if (this.pool) {
+    if (this.postgres) {
       try {
-        await this.pool.connect();
-        const result = await this.pool.query(query, args || []);
+        const result = await this.postgres.query(query, args || []);
         return {
           rows: result.rows,
           rowCount: result.rowCount || 0,
           command: result.command,
-          fields: result.fields
+          fields: result.fields?.map((field) => ({ name: field.name, dataTypeID: field.dataTypeID })) || []
         };
-      } catch (error) {
-        consola.error("Failed to connect to PostgreSQL pool:", error);
+      } catch (error2) {
+        consola.error("Failed to execute query with PostgreSQL:", error2);
+        throw error2;
       }
     }
     if (this.mysqlClient) {
@@ -292,25 +346,9 @@ class DriftSQLClient {
           // MySQL does not return command info
           fields: fields.map((field) => ({ name: field.name, dataTypeID: field.columnType }))
         };
-      } catch (error) {
-        consola.error("Failed to execute query with MySQL:", error);
-        throw error;
-      }
-    }
-    if (this.postgresClient) {
-      try {
-        const result = await this.postgresClient.unsafe(query, args || []);
-        return {
-          // @ts-ignore - postgres library returns rows directly
-          rows: result,
-          rowCount: result.length,
-          command: void 0,
-          fields: []
-          // postgres library does not provide field info
-        };
-      } catch (error) {
-        consola.error("Failed to execute query with postgres:", error);
-        throw error;
+      } catch (error2) {
+        consola.error("Failed to execute query with MySQL:", error2);
+        throw error2;
       }
     }
     if (this.libsqlClient) {
@@ -320,29 +358,14 @@ class DriftSQLClient {
           args: args || []
         });
         return this.convertLibsqlResult(result);
-      } catch (error) {
-        consola.error("Failed to execute query with libsql:", error);
-        throw error;
+      } catch (error2) {
+        consola.error("Failed to execute query with libsql:", error2);
+        throw error2;
       }
     }
-    try {
-      const response = await this.client.post("query", {
-        json: { query, args: args || [] }
-      });
-      return response.json();
-    } catch (error) {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error(`Query failed: ${JSON.stringify(error)}`);
-    }
-  }
-  async status() {
-    if (!this.client) {
-      throw new Error("HTTP client is not configured");
-    }
-    const response = await this.client.get("status");
-    return response.json();
+    const error = new Error("No database driver is configured or all drivers failed to execute the query");
+    consola.error(error);
+    throw error;
   }
   async findFirst(table, where) {
     const tableName = String(table);
@@ -424,8 +447,8 @@ class DriftSQLClient {
     return this.delete(table, where);
   }
   async close() {
-    if (this.pool) {
-      await this.pool.end();
+    if (this.postgres) {
+      await this.postgres.close();
     }
     if (this.libsqlClient) {
       this.libsqlClient.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftsql",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "author": "lasse vestergaard",
   "description": "A lightweight SQL client for TypeScript, supporting multiple databases like PostgreSQL, MySQL, and LibSQL.",
   "repository": "lassejlv/driftsql",