driftsql 1.0.8 → 1.0.10

package/dist/index.d.mts

@@ -1,6 +1,15 @@
-import { PoolConfig } from 'pg';
-import { Config } from '@libsql/client';
-import { ConnectionOptions } from 'mysql2/promise';
+interface PostgresConfig {
+    connectionString: string;
+}
+
+interface LibSQLConfig {
+    url: string;
+    authToken?: string;
+}
+
+interface MySQLConfig {
+    connectionString: string;
+}
 
 type Drivers = ClientOptions['drivers'];
 declare const inspectDB: (drivers: Drivers) => Promise<never>;
@@ -15,42 +24,20 @@ type UnifiedQueryResult<T extends Record<string, any>> = {
     }>;
 };
 interface ClientOptions {
-    /**
-     * @deprecated Since version 1.0.8 this option is deprecated and will be removed in future versions. Use `drivers.postgresHTTP.url` instead.
-     */
-    url?: string;
-    /**
-     * @deprecated Since version 1.0.8 this option is deprecated and will be removed in future versions. Use `drivers.postgresHTTP.url` instead.
-     */
-    password?: string;
-    drivers?: {
-        libsql?: Config;
-        postgres?: PoolConfig;
-        postgresHTTP?: {
-            url: string;
-            password: string;
-        };
-        mysql?: ConnectionOptions;
-    };
-    options?: {
-        defaultTimeout?: number;
+    drivers: {
+        libsql?: LibSQLConfig;
+        postgres?: PostgresConfig;
+        mysql?: MySQLConfig;
     };
 }
 declare class DriftSQLClient<DT> {
-    private client;
-    private pool?;
-    private mysqlClient?;
-    private libsqlClient?;
-    private postgresClient?;
+    private postgres?;
+    private libsql?;
+    private mysql?;
     private drivers;
     constructor(options: ClientOptions);
-    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]>;
@@ -64,4 +51,4 @@ declare class DriftSQLClient<DT> {
 }
 
 export { DriftSQLClient, inspectDB };
-export type { ClientOptions };
+export type { ClientOptions, UnifiedQueryResult };

package/dist/index.d.ts

@@ -1,6 +1,15 @@
-import { PoolConfig } from 'pg';
-import { Config } from '@libsql/client';
-import { ConnectionOptions } from 'mysql2/promise';
+interface PostgresConfig {
+    connectionString: string;
+}
+
+interface LibSQLConfig {
+    url: string;
+    authToken?: string;
+}
+
+interface MySQLConfig {
+    connectionString: string;
+}
 
 type Drivers = ClientOptions['drivers'];
 declare const inspectDB: (drivers: Drivers) => Promise<never>;
@@ -15,42 +24,20 @@ type UnifiedQueryResult<T extends Record<string, any>> = {
     }>;
 };
 interface ClientOptions {
-    /**
-     * @deprecated Since version 1.0.8 this option is deprecated and will be removed in future versions. Use `drivers.postgresHTTP.url` instead.
-     */
-    url?: string;
-    /**
-     * @deprecated Since version 1.0.8 this option is deprecated and will be removed in future versions. Use `drivers.postgresHTTP.url` instead.
-     */
-    password?: string;
-    drivers?: {
-        libsql?: Config;
-        postgres?: PoolConfig;
-        postgresHTTP?: {
-            url: string;
-            password: string;
-        };
-        mysql?: ConnectionOptions;
-    };
-    options?: {
-        defaultTimeout?: number;
+    drivers: {
+        libsql?: LibSQLConfig;
+        postgres?: PostgresConfig;
+        mysql?: MySQLConfig;
     };
 }
 declare class DriftSQLClient<DT> {
-    private client;
-    private pool?;
-    private mysqlClient?;
-    private libsqlClient?;
-    private postgresClient?;
+    private postgres?;
+    private libsql?;
+    private mysql?;
     private drivers;
     constructor(options: ClientOptions);
-    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]>;
@@ -64,4 +51,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 postgres from 'postgres';
 import { createClient } from '@libsql/client';
-import mysql from 'mysql2/promise';
+import * as mysql from 'mysql2/promise';
 import fs from 'node:fs/promises';
 
 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,144 +120,178 @@ 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" || activeDriver === "postgresHTTP") {
-    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" || 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 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;
-  mysqlClient;
-  libsqlClient;
-  postgresClient;
-  drivers;
+  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 LibSQLDriver {
   constructor(options) {
-    this.client = ky.create({
-      prefixUrl: options.drivers?.postgresHTTP.url || options.url || "http://localhost:3000",
-      headers: {
-        Authorization: `Bearer ${options.drivers?.postgresHTTP?.password || 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.options = options;
+    this.client = createClient({
+      url: this.options.url,
+      ...this.options.authToken ? { authToken: this.options.authToken } : {}
     });
-    this.pool = options.drivers?.postgres ? new Pool(options.drivers.postgres) : 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 || {};
   }
+  client;
   convertLibsqlResult(result) {
     const rows = result.rows.map((row) => {
       const obj = {};
@@ -256,93 +307,115 @@ class DriftSQLClient {
       fields: result.columns.map((col) => ({ name: col, dataTypeID: 0 }))
     };
   }
+  async query(query, params) {
+    try {
+      const result = await this.client.execute(query, params);
+      return this.convertLibsqlResult(result);
+    } catch (error) {
+      console.error("LibSQL query error:", error);
+      throw error;
+    }
+  }
+  async close() {
+    try {
+      this.client.close();
+    } catch (error) {
+      console.error("Error closing LibSQL client:", error);
+    }
+  }
+}
+
+class MySQLDriver {
+  constructor(options) {
+    this.options = options;
+    consola.warn("MySQL client is experimental and may not be compatible with the helper functions, since they originally designed for PostgreSQL and libsql. But .query() method should work.");
+    this.client = mysql.createConnection(this.options.connectionString);
+  }
+  client;
+  async query(query, params) {
+    try {
+      const [rows, fields] = await (await this.client).execute(query, params || []);
+      const rowCount = Array.isArray(rows) ? rows.length : 0;
+      return {
+        rows,
+        rowCount,
+        command: void 0,
+        fields: fields.map((field) => ({ name: field.name, dataTypeID: field.columnType }))
+      };
+    } catch (error) {
+      consola.error("MySQL query error:", error);
+      throw error;
+    }
+  }
+  async close() {
+    try {
+      await (await this.client).end();
+    } catch (error) {
+      consola.error("Error closing MySQL client:", error);
+    }
+  }
+}
+
+class DriftSQLClient {
+  postgres;
+  libsql;
+  mysql;
+  drivers;
+  constructor(options) {
+    this.postgres = options.drivers?.postgres ? new PostgresDriver({ connectionString: options.drivers.postgres.connectionString }) : void 0;
+    this.libsql = options.drivers?.libsql ? new LibSQLDriver(options.drivers.libsql) : void 0;
+    this.mysql = options.drivers?.mysql ? new MySQLDriver(options.drivers.mysql) : void 0;
+    this.drivers = options.drivers || {};
+  }
   inspect = async () => {
     return inspectDB(this.drivers);
   };
   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;
-    }
-    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) {
+    if (this.mysql) {
       try {
-        consola.warn("MySQL client is experimental and may not be compatible with the helper functions, since they originally designed for PostgreSQL and libsql. But .query() method should work.");
-        const filteredArgs = (args || []).map((arg) => arg === void 0 ? null : arg);
-        const [rows, fields] = await (await this.mysqlClient).execute(query, filteredArgs);
+        const result = await this.mysql.query(query, args || []);
         return {
-          rows,
-          rowCount: Array.isArray(rows) ? rows.length : 0,
-          command: void 0,
-          // MySQL does not return command info
-          fields: fields.map((field) => ({ name: field.name, dataTypeID: field.columnType }))
+          rows: result.rows,
+          rowCount: result.rowCount || 0,
+          command: result.command,
+          fields: result.fields?.map((field) => ({ name: field.name, dataTypeID: field.dataTypeID })) || []
         };
-      } catch (error) {
-        consola.error("Failed to execute query with MySQL:", error);
-        throw error;
+      } catch (error2) {
+        consola.error("Failed to execute query with MySQL:", error2);
+        throw error2;
       }
     }
-    if (this.postgresClient) {
+    if (this.libsql) {
       try {
-        const result = await this.postgresClient.unsafe(query, args || []);
+        const result = await this.libsql.query(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
+          rows: result.rows,
+          rowCount: result.rowCount || 0,
+          command: result.command,
+          fields: void 0
         };
-      } catch (error) {
-        consola.error("Failed to execute query with postgres:", error);
-        throw error;
+      } catch (error2) {
+        consola.error("Failed to execute query with LibSQL:", error2);
+        throw error2;
       }
     }
-    if (this.libsqlClient) {
-      try {
-        const result = await this.libsqlClient.execute({
-          sql: query,
-          args: args || []
-        });
-        return this.convertLibsqlResult(result);
-      } catch (error) {
-        consola.error("Failed to execute query with libsql:", error);
-        throw error;
-      }
-    }
-    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,17 +497,14 @@ class DriftSQLClient {
     return this.delete(table, where);
   }
   async close() {
-    if (this.pool) {
-      await this.pool.end();
-    }
-    if (this.libsqlClient) {
-      this.libsqlClient.close();
+    if (this.postgres) {
+      await this.postgres.close();
     }
-    if (this.mysqlClient) {
-      await (await this.mysqlClient).end();
+    if (this.libsql) {
+      this.libsql.close();
     }
-    if (this.postgresClient) {
-      await this.postgresClient.end();
+    if (this.mysql) {
+      await this.mysql.close();
     }
   }
 }

package/package.json

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