driftsql 1.0.0 → 1.0.2

package/README.md

@@ -23,7 +23,6 @@ A lightweight SQL client for TypeScript, supporting multiple databases like Post
 - **PostgreSQL** - Native PostgreSQL driver via `pg`
 - **LibSQL** - SQLite-compatible databases via `@libsql/client`
 - **HTTP** - HTTP-based database services
-- **Neon** - Neon serverless PostgreSQL (experimental)
 
 ## Usage
 
@@ -44,12 +43,6 @@ Import and use:
 import { DriftSQLClient } from 'driftsql'
 ```
 
-**CDN** (Deno, Bun and Browsers)
-
-```js
-import { DriftSQLClient } from 'https://esm.sh/driftsql'
-```
-
 <!-- /automd -->
 
 ## Quick Start
@@ -160,8 +153,6 @@ console.log(`Database OK: ${status.ok}, Ping: ${status.ping}ms`)
 await db.close()
 ```
 
-## API Reference
-
 ### Constructor Options
 
 ```typescript
@@ -182,62 +173,15 @@ interface ClientOptions {
 }
 ```
 
-### Methods
-
-- `query<T>(sql: string, args?: (string | number | boolean | null)[])` - Execute raw SQL with parameters
-- `findFirst<K>(table: K, where?: Partial<DT[K]>)` - Find first matching record
-- `findMany<K>(table: K, where?: Partial<DT[K]>)` - Find all matching records
-- `insert<K>(table: K, data: Partial<DT[K]>)` - Insert new record
-- `update<K>(table: K, data: Partial<DT[K]>, where: Partial<DT[K]>)` - Update records
-- `delete<K>(table: K, where: Partial<DT[K]>)` - Delete records
-- `deleteFirst<K>(table: K, where: Partial<DT[K]>)` - Delete first matching record
-- `status()` - Get server status and ping (HTTP driver only)
-- `close()` - Close database connections
-
-### Return Types
-
-All query methods return a unified result format:
-
-```typescript
-type UnifiedQueryResult<T> = {
-  rows: T[]
-  rowCount: number
-  command?: string
-  fields?: Array<{ name: string; dataTypeID: number }>
-}
-```
-
-## Development
-
-<details>
-
-<summary>local development</summary>
-
-- Clone this repository
-- Install latest LTS version of [Node.js](https://nodejs.org/en/)
-- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
-- Install dependencies using `pnpm install`
-- Run interactive tests using `pnpm dev`
-
 </details>
 
 ## License
 
 <!-- automd:contributors license=MIT -->
 
-Published under the [MIT](https://github.com/lassejlv/postgres-http-js/blob/main/LICENSE) license.
-Made by [community](https://github.com/lassejlv/postgres-http-js/graphs/contributors) 💛
+Published under the [MIT](https://github.com/lassejlv/driftsql/blob/main/LICENSE) license.
+Made by [community](https://github.com/lassejlv/driftsql/graphs/contributors) 💛
 <br><br>
-<a href="https://github.com/lassejlv/postgres-http-js/graphs/contributors">
-<img src="https://contrib.rocks/image?repo=lassejlv/postgres-http-js" />
+<a href="https://github.com/lassejlv/driftsql/graphs/contributors">
+<img src="https://contrib.rocks/image?repo=lassejlv/driftsql" />
 </a>
-
-<!-- /automd -->
-
-<!-- automd:with-automd -->
-
----
-
-_🤖 auto updated with [automd](https://automd.unjs.io)_
-
-<!-- /automd -->

package/dist/index.d.mts

@@ -1,5 +1,9 @@
 import { PoolConfig } from 'pg';
 import { Config } from '@libsql/client';
+import mysql from 'mysql2/promise';
+
+type Drivers = ClientOptions['drivers'];
+declare const inspectDB: (drivers: Drivers) => Promise<never>;
 
 type UnifiedQueryResult<T extends Record<string, any>> = {
     rows: T[];
@@ -16,10 +20,7 @@ interface ClientOptions {
     drivers?: {
         libsql?: Config;
         postgres?: PoolConfig;
-        /** @deprecated use the postgres driver instead */
-        postgresNeonHTTP?: {
-            connectionString: string;
-        };
+        mysql?: mysql.ConnectionOptions;
     };
     options?: {
         defaultTimeout?: number;
@@ -28,10 +29,14 @@ interface ClientOptions {
 declare class DriftSQLClient<DT> {
     private client;
     private pool?;
+    private mysqlClient?;
     private libsqlClient?;
     private neonClient?;
+    private postgresClient?;
+    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;
@@ -46,5 +51,5 @@ declare class DriftSQLClient<DT> {
     close(): Promise<void>;
 }
 
-export { DriftSQLClient };
+export { DriftSQLClient, inspectDB };
 export type { ClientOptions };

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 import { PoolConfig } from 'pg';
 import { Config } from '@libsql/client';
+import mysql from 'mysql2/promise';
+
+type Drivers = ClientOptions['drivers'];
+declare const inspectDB: (drivers: Drivers) => Promise<never>;
 
 type UnifiedQueryResult<T extends Record<string, any>> = {
     rows: T[];
@@ -16,10 +20,7 @@ interface ClientOptions {
     drivers?: {
         libsql?: Config;
         postgres?: PoolConfig;
-        /** @deprecated use the postgres driver instead */
-        postgresNeonHTTP?: {
-            connectionString: string;
-        };
+        mysql?: mysql.ConnectionOptions;
     };
     options?: {
         defaultTimeout?: number;
@@ -28,10 +29,14 @@ interface ClientOptions {
 declare class DriftSQLClient<DT> {
     private client;
     private pool?;
+    private mysqlClient?;
     private libsqlClient?;
     private neonClient?;
+    private postgresClient?;
+    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;
@@ -46,5 +51,5 @@ declare class DriftSQLClient<DT> {
     close(): Promise<void>;
 }
 
-export { DriftSQLClient };
+export { DriftSQLClient, inspectDB };
 export type { ClientOptions };

package/dist/index.mjs

@@ -2,13 +2,150 @@ import consola from 'consola';
 import ky from 'ky';
 import { Pool } from 'pg';
 import { createClient } from '@libsql/client';
-import { neon } from '@neondatabase/serverless';
+import mysql from 'mysql2/promise';
+import fs from 'node:fs/promises';
+
+const supportedDrivers = ["postgres"];
+const mapPostgresToTypeScript = (postgresType, isNullable = false) => {
+  const nullable = isNullable ? " | null" : "";
+  switch (postgresType.toLowerCase()) {
+    case "uuid": {
+      return `string${nullable}`;
+    }
+    case "character varying":
+    case "varchar":
+    case "text":
+    case "char":
+    case "character": {
+      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": {
+      return `number${nullable}`;
+    }
+    case "boolean":
+    case "bool": {
+      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": {
+      return `Date${nullable}`;
+    }
+    case "json":
+    case "jsonb": {
+      return `any${nullable}`;
+    }
+    case "array": {
+      return `any[]${nullable}`;
+    }
+    case "bytea": {
+      return `Buffer${nullable}`;
+    }
+    default: {
+      console.warn(`Unknown PostgreSQL type: ${postgresType}, defaulting to 'any'`);
+      return `any${nullable}`;
+    }
+  }
+};
+const inspectDB = async (drivers) => {
+  if (!drivers) throw new Error("No drivers provided for inspection");
+  const configuredDrivers = Object.keys(drivers).filter((key) => drivers[key] !== void 0);
+  if (configuredDrivers.length === 0) {
+    throw new Error("No drivers are configured");
+  }
+  const supportedConfiguredDrivers = configuredDrivers.filter((driver) => supportedDrivers.includes(driver));
+  if (supportedConfiguredDrivers.length === 0) {
+    throw new Error(`No supported drivers found. Configured: ${configuredDrivers.join(", ")}. Supported: ${supportedDrivers.join(", ")}`);
+  }
+  console.log(`Found supported drivers: ${supportedConfiguredDrivers.join(", ")}`);
+  let generatedTypes = "";
+  const client = new DriftSQLClient({ drivers });
+  const tables = await client.query(
+    `SELECT table_name 
+     FROM information_schema.tables 
+     WHERE table_schema = 'public' 
+     AND table_type = 'BASE TABLE'
+     ORDER BY table_name`
+  );
+  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}`);
+    const columns = await client.query(
+      `
+      SELECT 
+        column_name, 
+        data_type, 
+        is_nullable,
+        column_default
+      FROM information_schema.columns 
+      WHERE table_name = $1 
+      AND table_schema = 'public'
+      ORDER BY ordinal_position
+    `,
+      [tableName]
+    );
+    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 = mapPostgresToTypeScript(col.data_type, col.is_nullable === "YES");
+      generatedTypes += `  ${col.column_name}: ${tsType};
+`;
+    }
+    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 += "}\n\n";
+  await fs.writeFile("db-types.ts", generatedTypes, "utf8");
+  console.log("TypeScript types written to db-types.ts");
+  process.exit(0);
+};
 
 class DriftSQLClient {
   client;
   pool;
+  mysqlClient;
   libsqlClient;
   neonClient;
+  postgresClient;
+  drivers;
   constructor(options) {
     this.client = ky.create({
       prefixUrl: options.url,
@@ -30,7 +167,8 @@ class DriftSQLClient {
     });
     this.pool = options.drivers?.postgres ? new Pool(options.drivers.postgres) : void 0;
     this.libsqlClient = options.drivers?.libsql ? createClient(options.drivers.libsql) : void 0;
-    this.neonClient = options.drivers?.postgresNeonHTTP ? neon(options.drivers.postgresNeonHTTP.connectionString) : void 0;
+    this.mysqlClient = options.drivers?.mysql ? mysql.createConnection(options.drivers.mysql) : void 0;
+    this.drivers = options.drivers || {};
   }
   convertLibsqlResult(result) {
     const rows = result.rows.map((row) => {
@@ -47,6 +185,9 @@ class DriftSQLClient {
       fields: result.columns.map((col) => ({ name: col, dataTypeID: 0 }))
     };
   }
+  inspect = async () => {
+    return inspectDB(this.drivers);
+  };
   async query(query, args) {
     if (this.pool) {
       try {
@@ -62,6 +203,38 @@ class DriftSQLClient {
         consola.error("Failed to connect to PostgreSQL pool:", error);
       }
     }
+    if (this.mysqlClient) {
+      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 [rows, fields] = await (await this.mysqlClient).execute(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 }))
+        };
+      } 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;
+      }
+    }
     if (this.libsqlClient) {
       try {
         const result = await this.libsqlClient.execute({
@@ -191,4 +364,4 @@ class DriftSQLClient {
   }
 }
 
-export { DriftSQLClient };
+export { DriftSQLClient, inspectDB };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftsql",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "author": "lasse vestergaard",
   "description": "A lightweight SQL client for TypeScript, supporting multiple databases like PostgreSQL, MySQL, and LibSQL.",
   "repository": "lassejlv/driftsql",
@@ -47,6 +47,8 @@
     "driftsql": "^0.0.1",
     "drizzle-orm": "^0.44.2",
     "ky": "^1.8.1",
-    "pg": "^8.16.0"
+    "mysql2": "^3.14.1",
+    "pg": "^8.16.0",
+    "postgres": "^3.4.7"
   }
 }