driftsql 0.0.1 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,83 +1,243 @@
-# Drift SQL
+# DriftSQL
 
-Driftsql is a SQL client for libsql and sqlitecloud to provide a simple & fast way to query your data.
+<!-- automd:badges color=yellow -->
 
-## Installation
+[![npm version](https://img.shields.io/npm/v/driftsql?color=yellow)](https://npmjs.com/package/driftsql)
+[![npm downloads](https://img.shields.io/npm/dm/driftsql?color=yellow)](https://npm.chart.dev/driftsql)
 
-```bash
-bun add driftsql # or npm install driftsql
-```
+<!-- /automd -->
+
+A lightweight SQL client for TypeScript, supporting multiple databases like PostgreSQL, LibSQL, and HTTP-based database services. DriftSQL provides a unified, type-safe interface for database operations across different database drivers.
+
+## Features
+
+- 🔐 Type-safe database operations with TypeScript generics
+- 🛡️ SQL injection protection with parameterized queries
+- 🚀 Multiple driver support (PostgreSQL, LibSQL, HTTP)
+- 📝 Auto-completion support for database schema types
+- ⚡ Built-in error handling and connection management
+- 🔄 Unified API across different database types
+
+## Supported Drivers
+
+- **PostgreSQL** - Native PostgreSQL driver via `pg`
+- **LibSQL** - SQLite-compatible databases via `@libsql/client`
+- **HTTP** - HTTP-based database services
+- **Neon** - Neon serverless PostgreSQL (experimental)
 
 ## Usage
 
-For now docs are is very basic, but I will add more soon.
+Install the package:
 
-Setup client:
+```sh
+# ✨ Auto-detect (supports npm, yarn, pnpm, deno and bun)
+npx nypm install driftsql
+```
 
-```ts
-import { DriftClient } from 'driftsql';
+Import and use:
 
-const db = new DriftClient({
-  driver: 'libsql', // More drivers coming soon
-  auth: {
-    url: 'libsql://',
-    token: 'your-token',
-  },
-});
+<!-- automd:jsimport cdn name="driftsql" -->
+
+**ESM** (Node.js, Bun, Deno)
+
+```js
+import { DriftSQLClient } from 'driftsql'
+```
+
+**CDN** (Deno, Bun and Browsers)
+
+```js
+import { DriftSQLClient } from 'https://esm.sh/driftsql'
 ```
 
-### Type-safety
+<!-- /automd -->
+
+## Quick Start
+
+### Define Your Database Schema
 
-You can add an type to your database client to get type-safety and autocompletion. Example:
+```typescript
+import { DriftSQLClient } from 'driftsql'
 
-```ts
-import { DriftClient } from 'driftsql';
+// Define your database schema types
+interface User {
+  id: number
+  name: string
+  email: string
+  created_at: string
+}
+
+interface Post {
+  id: number
+  title: string
+  content: string | null
+  user_id: number | null
+  published: boolean
+  created_at: Date
+  updated_at: Date
+}
 
-interface Database {
-  users: {
-    id: number;
-    name: string;
-    email: string;
-    password: string;
-    created_at: string;
-  };
+// Define your database schema
+interface MyDatabase {
+  users: User
+  posts: Post
 }
+```
+
+### Initialize with PostgreSQL
+
+```typescript
+const db = new DriftSQLClient<MyDatabase>({
+  drivers: {
+    postgres: {
+      connectionString: 'postgresql://user:password@localhost:5432/mydb',
+      // or individual options:
+      // host: 'localhost',
+      // port: 5432,
+      // database: 'mydb',
+      // user: 'user',
+      // password: 'password'
+    },
+  },
+})
+```
 
-const db = new DriftClient<Database>({
-  driver: 'libsql',
-  auth: {
-    url: 'libsql://',
-    token: 'your-token',
+### Initialize with LibSQL
+
+```typescript
+const db = new DriftSQLClient<MyDatabase>({
+  drivers: {
+    libsql: {
+      url: 'file:local.db',
+      // or for remote:
+      // url: 'libsql://your-database.turso.io',
+      // authToken: 'your-auth-token'
+    },
   },
-});
+})
 ```
 
-Now you can query your database with a developer-friendly api inspired by Prisma.
+### Initialize with HTTP
 
-```ts
-// Find all users
-// in every find method, you can pass a where object to filter the results
-const users = await db.findMany({ table: 'users' });
+```typescript
+const db = new DriftSQLClient<MyDatabase>({
+  url: 'https://your-database-api.com',
+  password: 'your-bearer-token',
+  options: {
+    defaultTimeout: 5000, // optional, defaults to 5000ms
+  },
+})
+```
 
-// Find a single user
-const user = await db.findOne({ table: 'users', id: 1 });
+### Database Operations
 
-// Find the first user
-const user = await db.findFirst({ table: 'users', where: { id: 1 } });
+```typescript
+// Raw SQL queries
+const users = await db.query<User>('SELECT * FROM users WHERE active = $1', [true])
+console.log(users.rows)
 
-// Create a new user
-const user = await db.create({ table: 'users', data: { name: 'John Doe', email: 'john@doe.com', password: 'password' } });
+// Find operations
+const user = await db.findFirst('users', { email: 'user@example.com' })
+const activeUsers = await db.findMany('users', { active: true })
 
-// Update a user
-const user = await db.update({ table: 'users', where: { id: 1 }, data: { name: 'John Doe' } });
+// Insert operations
+const newUser = await db.insert('users', {
+  name: 'John Doe',
+  email: 'john@example.com',
+})
 
-// Delete a user
-const user = await db.delete({ table: 'users', where: { id: 1 } });
+// Update operations
+const updatedUser = await db.update('users', { name: 'Jane Doe' }, { id: 1 })
 
-// Delete many users
-const users = await db.deleteMany({ table: 'users', where: { id: [1, 2, 3] } });
+// Delete operations
+const deleted = await db.delete('users', { id: 1 })
+
+// Check server status (HTTP only)
+const status = await db.status()
+console.log(`Database OK: ${status.ok}, Ping: ${status.ping}ms`)
+
+// Clean up connections
+await db.close()
+```
+
+## API Reference
+
+### Constructor Options
+
+```typescript
+interface ClientOptions {
+  url?: string // HTTP server URL (for HTTP driver)
+  password?: string // Bearer token for HTTP authentication
+  drivers?: {
+    libsql?: LibsqlClientConfig // LibSQL configuration
+    postgres?: PoolConfig // PostgreSQL configuration
+    postgresNeonHTTP?: {
+      // Neon configuration (experimental)
+      connectionString: string
+    }
+  }
+  options?: {
+    defaultTimeout?: number // Request timeout in milliseconds
+  }
+}
+```
+
+### 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
 
-MIT
+<!-- 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) 💛
+<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>
+
+<!-- /automd -->
+
+<!-- automd:with-automd -->
+
+---
+
+_🤖 auto updated with [automd](https://automd.unjs.io)_
+
+<!-- /automd -->

package/dist/index.d.mts

@@ -0,0 +1,50 @@
+import { PoolConfig } from 'pg';
+import { Config } from '@libsql/client';
+
+type UnifiedQueryResult<T extends Record<string, any>> = {
+    rows: T[];
+    rowCount: number;
+    command?: string;
+    fields?: Array<{
+        name: string;
+        dataTypeID: number;
+    }>;
+};
+interface ClientOptions {
+    url?: string;
+    password?: string;
+    drivers?: {
+        libsql?: Config;
+        postgres?: PoolConfig;
+        /** @deprecated use the postgres driver instead */
+        postgresNeonHTTP?: {
+            connectionString: string;
+        };
+    };
+    options?: {
+        defaultTimeout?: number;
+    };
+}
+declare class DriftSQLClient<DT> {
+    private client;
+    private pool?;
+    private libsqlClient?;
+    private neonClient?;
+    constructor(options: ClientOptions);
+    private convertLibsqlResult;
+    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, where?: Partial<DT[K]>): Promise<DT[K][]>;
+    insert<K extends keyof DT>(table: K, data: Partial<DT[K]>): Promise<DT[K]>;
+    update<K extends keyof DT>(table: K, data: Partial<DT[K]>, where: Partial<DT[K]>): Promise<DT[K] | null>;
+    delete<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<boolean>;
+    deleteFirst<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<boolean>;
+    close(): Promise<void>;
+}
+
+export { DriftSQLClient };
+export type { ClientOptions };

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+import { PoolConfig } from 'pg';
+import { Config } from '@libsql/client';
+
+type UnifiedQueryResult<T extends Record<string, any>> = {
+    rows: T[];
+    rowCount: number;
+    command?: string;
+    fields?: Array<{
+        name: string;
+        dataTypeID: number;
+    }>;
+};
+interface ClientOptions {
+    url?: string;
+    password?: string;
+    drivers?: {
+        libsql?: Config;
+        postgres?: PoolConfig;
+        /** @deprecated use the postgres driver instead */
+        postgresNeonHTTP?: {
+            connectionString: string;
+        };
+    };
+    options?: {
+        defaultTimeout?: number;
+    };
+}
+declare class DriftSQLClient<DT> {
+    private client;
+    private pool?;
+    private libsqlClient?;
+    private neonClient?;
+    constructor(options: ClientOptions);
+    private convertLibsqlResult;
+    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, where?: Partial<DT[K]>): Promise<DT[K][]>;
+    insert<K extends keyof DT>(table: K, data: Partial<DT[K]>): Promise<DT[K]>;
+    update<K extends keyof DT>(table: K, data: Partial<DT[K]>, where: Partial<DT[K]>): Promise<DT[K] | null>;
+    delete<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<boolean>;
+    deleteFirst<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<boolean>;
+    close(): Promise<void>;
+}
+
+export { DriftSQLClient };
+export type { ClientOptions };

package/dist/index.mjs

@@ -0,0 +1,194 @@
+import consola from 'consola';
+import ky from 'ky';
+import { Pool } from 'pg';
+import { createClient } from '@libsql/client';
+import { neon } from '@neondatabase/serverless';
+
+class DriftSQLClient {
+  client;
+  pool;
+  libsqlClient;
+  neonClient;
+  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.libsqlClient = options.drivers?.libsql ? createClient(options.drivers.libsql) : void 0;
+    this.neonClient = options.drivers?.postgresNeonHTTP ? neon(options.drivers.postgresNeonHTTP.connectionString) : void 0;
+  }
+  convertLibsqlResult(result) {
+    const rows = result.rows.map((row) => {
+      const obj = {};
+      result.columns.forEach((col, index) => {
+        obj[col] = row[index];
+      });
+      return obj;
+    });
+    return {
+      rows,
+      rowCount: result.rowsAffected || rows.length,
+      command: void 0,
+      fields: result.columns.map((col) => ({ name: col, dataTypeID: 0 }))
+    };
+  }
+  async query(query, args) {
+    if (this.pool) {
+      try {
+        await this.pool.connect();
+        const result = await this.pool.query(query, args || []);
+        return {
+          rows: result.rows,
+          rowCount: result.rowCount || 0,
+          command: result.command,
+          fields: result.fields
+        };
+      } catch (error) {
+        consola.error("Failed to connect to PostgreSQL pool:", error);
+      }
+    }
+    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;
+      }
+    }
+    if (this.neonClient) {
+      try {
+        const sql = this.neonClient;
+        console.log(sql);
+        throw new Error("Neon client is not implemented yet");
+        return {
+          rows: [],
+          rowCount: 0
+        };
+      } catch (error) {
+        consola.error("Failed to execute query with Neon:", 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();
+  }
+  async findFirst(table, where) {
+    const tableName = String(table);
+    const whereEntries = Object.entries(where || {});
+    let query = `SELECT * FROM ${tableName}`;
+    let args = [];
+    if (whereEntries.length > 0) {
+      const whereClause = whereEntries.map(([key], index) => `${key} = $${index + 1}`).join(" AND ");
+      query += ` WHERE ${whereClause}`;
+      args = whereEntries.map(([, value]) => value);
+    }
+    query += " LIMIT 1";
+    const result = await this.query(query, args);
+    return result.rows[0] || null;
+  }
+  async findMany(table, where) {
+    const tableName = String(table);
+    const whereEntries = Object.entries(where || {});
+    let query = `SELECT * FROM ${tableName}`;
+    let args = [];
+    if (whereEntries.length > 0) {
+      const whereClause = whereEntries.map(([key], index) => `${key} = $${index + 1}`).join(" AND ");
+      query += ` WHERE ${whereClause}`;
+      args = whereEntries.map(([, value]) => value);
+    }
+    const result = await this.query(query, args);
+    return result.rows;
+  }
+  async insert(table, data) {
+    const tableName = String(table);
+    const keys = Object.keys(data);
+    const values = Object.values(data).map((value) => value);
+    if (keys.length === 0) {
+      throw new Error("No data provided for insert");
+    }
+    const placeholders = keys.map((_, index) => `$${index + 1}`).join(", ");
+    const query = `INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;
+    const result = await this.query(query, values);
+    if (!result.rows[0]) {
+      throw new Error("Insert failed: No data returned");
+    }
+    return result.rows[0];
+  }
+  async update(table, data, where) {
+    const tableName = String(table);
+    const setEntries = Object.entries(data);
+    const whereEntries = Object.entries(where);
+    if (setEntries.length === 0) {
+      throw new Error("No data provided for update");
+    }
+    if (whereEntries.length === 0) {
+      throw new Error("No conditions provided for update");
+    }
+    const setClause = setEntries.map(([key], index) => `${key} = $${index + 1}`).join(", ");
+    const whereClause = whereEntries.map(([key], index) => `${key} = $${setEntries.length + index + 1}`).join(" AND ");
+    const query = `UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;
+    const args = [...setEntries.map(([, value]) => value), ...whereEntries.map(([, value]) => value)];
+    const result = await this.query(query, args);
+    return result.rows[0] || null;
+  }
+  async delete(table, where) {
+    const tableName = String(table);
+    const whereEntries = Object.entries(where);
+    if (whereEntries.length === 0) {
+      throw new Error("No conditions provided for delete");
+    }
+    const whereClause = whereEntries.map(([key], index) => `${key} = $${index + 1}`).join(" AND ");
+    const query = `DELETE FROM ${tableName} WHERE ${whereClause}`;
+    const args = whereEntries.map(([, value]) => value);
+    const result = await this.query(query, args);
+    return (result.rowCount || 0) > 0;
+  }
+  deleteFirst(table, where) {
+    return this.delete(table, where);
+  }
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+    }
+    if (this.libsqlClient) {
+      this.libsqlClient.close();
+    }
+  }
+}
+
+export { DriftSQLClient };

package/package.json

@@ -1,19 +1,52 @@
 {
   "name": "driftsql",
-  "version": "0.0.1",
-  "description": "Driftsql is a SQL client for libsql and sqlitecloud to provide a simple & fast way to query your data.",
-  "module": "src/main.ts",
+  "version": "1.0.0",
+  "author": "lasse vestergaard",
+  "description": "A lightweight SQL client for TypeScript, supporting multiple databases like PostgreSQL, MySQL, and LibSQL.",
+  "repository": "lassejlv/driftsql",
+  "license": "MIT",
+  "sideEffects": false,
   "type": "module",
-  "main": "dist/main.js",
-  "devDependencies": {
-    "@types/bun": "latest"
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier -c .",
+    "lint:fix": "automd && eslint . --fix && prettier -w .",
+    "prepack": "pnpm build",
+    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "test:types": "tsc --noEmit --skipLibCheck"
   },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
+  "devDependencies": {
+    "@types/node": "^22.13.13",
+    "@vitest/coverage-v8": "^3.0.9",
+    "automd": "^0.4.0",
+    "changelogen": "^0.6.1",
+    "eslint": "^9.23.0",
+    "eslint-config-unjs": "^0.4.2",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.2",
+    "unbuild": "^3.5.0",
+    "vitest": "^3.0.9"
   },
+  "packageManager": "pnpm@10.12.1",
   "dependencies": {
-    "@libsql/client": "^0.14.0",
-    "prismoo": "^1.1.2",
-    "zod": "^3.23.8"
+    "@libsql/client": "^0.15.9",
+    "@neondatabase/serverless": "^1.0.1",
+    "@types/pg": "^8.15.4",
+    "consola": "^3.4.2",
+    "driftsql": "^0.0.1",
+    "drizzle-orm": "^0.44.2",
+    "ky": "^1.8.1",
+    "pg": "^8.16.0"
   }
 }