driftsql 1.0.13 → 1.0.14

package/dist/index.d.mts

@@ -81,6 +81,33 @@ declare class SqliteDriver implements DatabaseDriver, TransactionCapable, Prepar
     pragma(pragma: string): any;
 }
 
+interface InspectOptions {
+    driver: DatabaseDriver;
+    outputFile?: string;
+}
+declare const inspectDB: (options: InspectOptions) => Promise<void>;
+declare const inspectPostgres: (config: {
+    connectionString?: string;
+    experimental?: {
+        http?: {
+            url: string;
+            apiKey?: string;
+        };
+    };
+}, outputFile?: string) => Promise<void>;
+declare const inspectLibSQL: (config: {
+    url: string;
+    authToken?: string;
+    useTursoServerlessDriver?: boolean;
+}, outputFile?: string) => Promise<void>;
+declare const inspectMySQL: (config: {
+    connectionString: string;
+}, outputFile?: string) => Promise<void>;
+declare const inspectSQLite: (config: {
+    filename: string;
+    readonly?: boolean;
+}, outputFile?: string) => Promise<void>;
+
 interface ClientOptions<T extends DatabaseDriver = DatabaseDriver> {
     driver: T;
     fallbackDrivers?: DatabaseDriver[];
@@ -129,5 +156,5 @@ declare function createSqliteClient<DT = any>(config: {
 }): SQLClient<DT>;
 declare const DriftSQLClient: typeof SQLClient;
 
-export { DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient };
+export { DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient, inspectDB, inspectLibSQL, inspectMySQL, inspectPostgres, inspectSQLite };
 export type { ClientOptions, DatabaseDriver, QueryResult };

package/dist/index.d.ts

@@ -81,6 +81,33 @@ declare class SqliteDriver implements DatabaseDriver, TransactionCapable, Prepar
     pragma(pragma: string): any;
 }
 
+interface InspectOptions {
+    driver: DatabaseDriver;
+    outputFile?: string;
+}
+declare const inspectDB: (options: InspectOptions) => Promise<void>;
+declare const inspectPostgres: (config: {
+    connectionString?: string;
+    experimental?: {
+        http?: {
+            url: string;
+            apiKey?: string;
+        };
+    };
+}, outputFile?: string) => Promise<void>;
+declare const inspectLibSQL: (config: {
+    url: string;
+    authToken?: string;
+    useTursoServerlessDriver?: boolean;
+}, outputFile?: string) => Promise<void>;
+declare const inspectMySQL: (config: {
+    connectionString: string;
+}, outputFile?: string) => Promise<void>;
+declare const inspectSQLite: (config: {
+    filename: string;
+    readonly?: boolean;
+}, outputFile?: string) => Promise<void>;
+
 interface ClientOptions<T extends DatabaseDriver = DatabaseDriver> {
     driver: T;
     fallbackDrivers?: DatabaseDriver[];
@@ -129,5 +156,5 @@ declare function createSqliteClient<DT = any>(config: {
 }): SQLClient<DT>;
 declare const DriftSQLClient: typeof SQLClient;
 
-export { DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient };
+export { DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient, inspectDB, inspectLibSQL, inspectMySQL, inspectPostgres, inspectSQLite };
 export type { ClientOptions, DatabaseDriver, QueryResult };

package/dist/index.mjs

@@ -5,6 +5,7 @@ import { createClient as createClient$1 } from '@libsql/client';
 import { createClient } from '@tursodatabase/serverless/compat';
 import * as mysql from 'mysql2/promise';
 import Database from 'better-sqlite3';
+import fs from 'node:fs/promises';
 
 function hasTransactionSupport(driver) {
   return "transaction" in driver && typeof driver.transaction === "function";
@@ -311,6 +312,272 @@ class SqlitePreparedStatement {
   }
 }
 
+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();
+  switch (lowerType) {
+    case "uuid": {
+      return `string${nullable}`;
+    }
+    case "character varying":
+    case "varchar":
+    case "text":
+    case "char":
+    case "character":
+    case "longtext":
+    case "mediumtext":
+    case "tinytext": {
+      return `string${nullable}`;
+    }
+    case "integer":
+    case "int":
+    case "int4":
+    case "smallint":
+    case "int2":
+    case "bigint":
+    case "int8":
+    case "serial":
+    case "bigserial":
+    case "numeric":
+    case "decimal":
+    case "real":
+    case "float4":
+    case "double precision":
+    case "float8":
+    case "tinyint":
+    case "mediumint":
+    case "float":
+    case "double": {
+      return `number${nullable}`;
+    }
+    case "boolean":
+    case "bool":
+    case "bit": {
+      return `boolean${nullable}`;
+    }
+    case "timestamp":
+    case "timestamp with time zone":
+    case "timestamp without time zone":
+    case "timestamptz":
+    case "date":
+    case "time":
+    case "time with time zone":
+    case "time without time zone":
+    case "timetz":
+    case "interval":
+    case "datetime":
+    case "year": {
+      return `Date${nullable}`;
+    }
+    case "json":
+    case "jsonb": {
+      return `any${nullable}`;
+    }
+    case "array": {
+      return `any[]${nullable}`;
+    }
+    case "bytea":
+    case "binary":
+    case "varbinary":
+    case "blob":
+    case "longblob":
+    case "mediumblob":
+    case "tinyblob": {
+      return `Buffer${nullable}`;
+    }
+    case "enum":
+    case "set": {
+      return `string${nullable}`;
+    }
+    default: {
+      console.warn(`Unknown ${driverType} type: ${dataType}, defaulting to 'any'`);
+      return `any${nullable}`;
+    }
+  }
+};
+const getDriverType = (driver) => {
+  if (driver instanceof PostgresDriver) return "postgres";
+  if (driver instanceof LibSQLDriver) return "libsql";
+  if (driver instanceof MySQLDriver) return "mysql";
+  if (driver instanceof SqliteDriver) return "sqlite";
+  return "unknown";
+};
+const inspectDB = async (options) => {
+  const { driver, outputFile = "db-types.ts" } = options;
+  const driverType = getDriverType(driver);
+  console.log(`Inspecting database using ${driverType} driver`);
+  const client = new SQLClient({ driver });
+  let generatedTypes = "";
+  try {
+    let tablesQuery;
+    let tableSchemaFilter;
+    if (driverType === "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 (driverType === "postgres") {
+      tablesQuery = `SELECT table_name
+                   FROM information_schema.tables
+                   WHERE table_schema = $1
+                   AND table_type = 'BASE TABLE'
+                   ORDER BY table_name`;
+      tableSchemaFilter = "public";
+    } else if (driverType === "libsql" || driverType === "sqlite") {
+      tablesQuery = `SELECT name as table_name
+                   FROM sqlite_master
+                   WHERE type = 'table'
+                   ORDER BY name`;
+      tableSchemaFilter = void 0;
+    } else {
+      throw new Error(`Unsupported driver type: ${driverType}`);
+    }
+    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 (driverType === "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 (driverType === "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 withTimeout(
+          retryQuery(
+            () => client.query(columnsQuery, queryParams)
+          ),
+          15e3
+        );
+        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", driverType);
+          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 += "export interface Database {\n";
+    for (const table of tables.rows) {
+      const interfaceName = table.table_name.charAt(0).toUpperCase() + table.table_name.slice(1);
+      generatedTypes += `  ${table.table_name}: ${interfaceName};
+`;
+    }
+    generatedTypes += "}\n\n";
+    await fs.writeFile(outputFile, generatedTypes, "utf8");
+    console.log(`TypeScript types written to ${outputFile}`);
+    console.log(`Successfully processed ${processedTables} tables`);
+  } catch (error) {
+    console.error("Fatal error during database inspection:", error);
+    throw error;
+  } finally {
+    await client.close();
+  }
+};
+const inspectPostgres = async (config, outputFile) => {
+  const driver = new PostgresDriver(config);
+  return inspectDB({ driver, outputFile });
+};
+const inspectLibSQL = async (config, outputFile) => {
+  const driver = new LibSQLDriver(config);
+  return inspectDB({ driver, outputFile });
+};
+const inspectMySQL = async (config, outputFile) => {
+  const driver = new MySQLDriver(config);
+  return inspectDB({ driver, outputFile });
+};
+const inspectSQLite = async (config, outputFile) => {
+  const driver = new SqliteDriver(config);
+  return inspectDB({ driver, outputFile });
+};
+
 class SQLClient {
   primaryDriver;
   fallbackDrivers;
@@ -465,4 +732,4 @@ function createSqliteClient(config) {
 }
 const DriftSQLClient = SQLClient;
 
-export { DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient };
+export { DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient, inspectDB, inspectLibSQL, inspectMySQL, inspectPostgres, inspectSQLite };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftsql",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "author": "lasse vestergaard",
   "description": "A lightweight SQL client for TypeScript",
   "repository": "lassejlv/driftsql",