@lunarhue/expo-wa-sqlite 0.0.1

package/lovely-docs/drizzle-orm/connect-aws-data-api-pg.md

@@ -0,0 +1,47 @@
+## AWS Data API Postgres Connection
+
+Connect Drizzle ORM to AWS RDS Aurora PostgreSQL using AWS Data API.
+
+**Prerequisites:**
+- Database connection basics with Drizzle
+- AWS Data API (Aurora RDS)
+- AWS SDK v3
+
+**Installation:**
+```
+npm install drizzle-orm @aws-sdk/client-rds-data
+npm install -D drizzle-kit
+```
+
+**Setup - Option 1 (Auto-create client):**
+```typescript
+import { drizzle } from 'drizzle-orm/aws-data-api/pg';
+
+const db = drizzle({ 
+  connection: {
+    database: process.env['DATABASE']!,
+    secretArn: process.env['SECRET_ARN']!,
+    resourceArn: process.env['RESOURCE_ARN']!,
+  }
+});
+
+await db.select().from(...);
+```
+
+**Setup - Option 2 (Provide existing RDSDataClient):**
+```typescript
+import { drizzle } from 'drizzle-orm/aws-data-api/pg';
+import { RDSDataClient } from '@aws-sdk/client-rds-data';
+
+const rdsClient = new RDSDataClient({ region: 'us-east-1' });
+
+const db = drizzle(rdsClient, {
+  database: process.env['DATABASE']!,
+  secretArn: process.env['SECRET_ARN']!,
+  resourceArn: process.env['RESOURCE_ARN']!,
+});
+
+await db.select().from(...);
+```
+
+Three required connection properties: `database`, `secretArn`, `resourceArn`. Additional RDSDataClient properties can be specified in the connection object.

package/lovely-docs/drizzle-orm/connect-bun-sql.md

@@ -0,0 +1,35 @@
+## Bun SQL Integration
+
+Drizzle ORM natively supports Bun's SQL module for PostgreSQL database connections.
+
+**Prerequisites:**
+- Database connection basics with Drizzle
+- Bun runtime (fast all-in-one JavaScript runtime)
+- Bun SQL - native PostgreSQL bindings
+
+**Installation:**
+```
+npm install drizzle-orm
+npm install -D drizzle-kit
+```
+
+**Basic usage - auto-initialize driver:**
+```typescript
+import 'dotenv/config';
+import { drizzle } from 'drizzle-orm/bun-sql';
+
+const db = drizzle(process.env.DATABASE_URL);
+const result = await db.select().from(...);
+```
+
+**With existing driver:**
+```typescript
+import 'dotenv/config';
+import { drizzle } from 'drizzle-orm/bun-sql';
+import { SQL } from 'bun';
+
+const client = new SQL(process.env.DATABASE_URL!);
+const db = drizzle({ client });
+```
+
+Bun SQL integration is noted as "crazy fast".

package/lovely-docs/drizzle-orm/connect-bun-sqlite.md

@@ -0,0 +1,42 @@
+## Bun SQLite Integration
+
+Drizzle ORM natively supports the `bun:sqlite` module with both async and sync APIs.
+
+### Installation
+```
+npm install drizzle-orm
+npm install -D drizzle-kit
+```
+
+### Basic Setup
+Initialize with default driver:
+```typescript
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+const db = drizzle();
+const result = await db.select().from(...);
+```
+
+Or provide an existing Bun SQLite driver:
+```typescript
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+import { Database } from 'bun:sqlite';
+
+const sqlite = new Database('sqlite.db');
+const db = drizzle({ client: sqlite });
+```
+
+### Async API
+```typescript
+const result = await db.select().from(users);
+```
+
+### Sync API
+For synchronous operations, use the following methods:
+```typescript
+const result = db.select().from(users).all();
+const result = db.select().from(users).get();
+const result = db.select().from(users).values();
+const result = db.select().from(users).run();
+```
+
+The sync API mirrors popular SQLite methods: `all`, `get`, `values`, and `run`.

package/lovely-docs/drizzle-orm/connect-cloudflare-d1.md

@@ -0,0 +1,61 @@
+## Cloudflare D1 Integration
+
+D1 is Cloudflare's queryable relational database. Drizzle ORM fully supports D1 and Cloudflare Workers environment with SQLite-like query methods (`all`, `get`, `values`, `run`).
+
+### Installation
+```
+npm install drizzle-orm
+npm install -D drizzle-kit
+```
+
+### Configuration
+Create `wrangler.json` or `wrangler.toml` with D1 database binding:
+
+**wrangler.json:**
+```json
+{
+    "name": "YOUR_PROJECT_NAME",
+    "main": "src/index.ts",
+    "compatibility_date": "2024-09-26",
+    "compatibility_flags": ["nodejs_compat"],
+    "d1_databases": [{
+        "binding": "BINDING_NAME",
+        "database_name": "YOUR_DB_NAME",
+        "database_id": "YOUR_DB_ID",
+        "migrations_dir": "drizzle/migrations"
+    }]
+}
+```
+
+**wrangler.toml:**
+```toml
+name = "YOUR_PROJECT_NAME"
+main = "src/index.ts"
+compatibility_date = "2022-11-07"
+node_compat = true
+
+[[ d1_databases ]]
+binding = "BINDING_NAME"
+database_name = "YOUR_DB_NAME"
+database_id = "YOUR_DB_ID"
+migrations_dir = "drizzle/migrations"
+```
+
+### Usage
+```typescript
+import { drizzle } from 'drizzle-orm/d1';
+
+export interface Env {
+  <BINDING_NAME>: D1Database;
+}
+
+export default {
+  async fetch(request: Request, env: Env) {
+    const db = drizzle(env.<BINDING_NAME>);
+    const result = await db.select().from(users).all();
+    return Response.json(result);
+  },
+};
+```
+
+Initialize driver with `drizzle(env.<BINDING_NAME>)` and use standard Drizzle query syntax.

package/lovely-docs/drizzle-orm/connect-cloudflare-do.md

@@ -0,0 +1,86 @@
+## Cloudflare Durable Objects SQLite Setup
+
+Drizzle ORM fully supports Cloudflare Durable Objects SQLite databases in Cloudflare Workers environment.
+
+### Prerequisites
+- Database connection basics with Drizzle
+- Cloudflare SQLite Durable Objects - SQLite database embedded within a Durable Object
+
+### Installation
+```
+npm install drizzle-orm
+npm install -D drizzle-kit
+```
+
+### Configuration
+
+Create `wrangler.toml` with Durable Object bindings and migrations:
+```toml
+name = "sqlite-durable-objects"
+main = "src/index.ts"
+compatibility_date = "2024-11-12"
+compatibility_flags = [ "nodejs_compat" ]
+
+[[durable_objects.bindings]]
+name = "MY_DURABLE_OBJECT"
+class_name = "MyDurableObject"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["MyDurableObject"]
+
+[[rules]] 
+type = "Text"
+globs = ["**/*.sql"]
+fallthrough = true
+```
+
+### Usage
+
+Initialize driver and create Durable Object class:
+```typescript
+import { drizzle, DrizzleSqliteDODatabase } from 'drizzle-orm/durable-sqlite';
+import { DurableObject } from 'cloudflare:workers'
+import { migrate } from 'drizzle-orm/durable-sqlite/migrator';
+import migrations from '../drizzle/migrations';
+import { usersTable } from './db/schema';
+
+export class MyDurableObject extends DurableObject {
+	storage: DurableObjectStorage;
+	db: DrizzleSqliteDODatabase<any>;
+
+	constructor(ctx: DurableObjectState, env: Env) {
+		super(ctx, env);
+		this.storage = ctx.storage;
+		this.db = drizzle(this.storage, { logger: false });
+
+		ctx.blockConcurrencyWhile(async () => {
+			await migrate(this.db, migrations);
+		});
+	}
+
+	async insertAndList(user: typeof usersTable.$inferInsert) {
+		await this.db.insert(usersTable).values(user);
+		return this.db.select().from(usersTable);
+	}
+}
+
+export default {
+	async fetch(request: Request, env: Env): Promise<Response> {
+		const id = env.MY_DURABLE_OBJECT.idFromName('durable-object');
+		const stub = env.MY_DURABLE_OBJECT.get(id);
+
+		const users = await stub.insertAndList({
+			name: 'John',
+			age: 30,
+			email: 'john@example.com',
+		});
+		return Response.json(users);
+	}
+}
+```
+
+### Performance Notes
+- Bundle all database interactions within a single Durable Object call for maximum performance
+- Each individual query call is a round-trip to the Durable Object instance
+- Run migrations during initialization with `blockConcurrencyWhile()` to prevent concurrent access before migrations complete

package/lovely-docs/drizzle-orm/connect-neon.md

@@ -0,0 +1,72 @@
+## Neon Postgres Connection
+
+Drizzle has native support for Neon serverless database connections using `neon-http` and `neon-websockets` drivers, which wrap the neon-serverless driver. HTTP is faster for single non-interactive transactions; WebSockets support session and interactive transactions.
+
+### Installation
+```
+drizzle-orm @neondatabase/serverless
+-D drizzle-kit
+```
+
+### Neon HTTP
+```typescript
+import { drizzle } from 'drizzle-orm/neon-http';
+const db = drizzle(process.env.DATABASE_URL);
+const result = await db.execute('select 1');
+```
+
+Or with existing driver:
+```typescript
+import { neon } from '@neondatabase/serverless';
+import { drizzle } from 'drizzle-orm/neon-http';
+const sql = neon(process.env.DATABASE_URL!);
+const db = drizzle({ client: sql });
+```
+
+### Neon WebSockets
+```typescript
+import { drizzle } from 'drizzle-orm/neon-serverless';
+const db = drizzle(process.env.DATABASE_URL);
+```
+
+For Node.js (requires `ws` and `bufferutil` packages):
+```typescript
+import { drizzle } from 'drizzle-orm/neon-serverless';
+import ws from 'ws';
+const db = drizzle({ connection: process.env.DATABASE_URL, ws: ws });
+```
+
+Or with existing Pool:
+```typescript
+import { Pool } from '@neondatabase/serverless';
+import { drizzle } from 'drizzle-orm/neon-serverless';
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const db = drizzle({ client: pool });
+```
+
+For Node.js with Pool:
+```typescript
+import { Pool, neonConfig } from '@neondatabase/serverless';
+import ws from 'ws';
+neonConfig.webSocketConstructor = ws;
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const db = drizzle({ client: pool });
+```
+
+### node-postgres
+```typescript
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const db = drizzle({ client: pool });
+```
+
+### postgres.js
+```typescript
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+const queryClient = postgres(process.env.DATABASE_URL);
+const db = drizzle({ client: queryClient });
+```
+
+For serverful Node.js environments, use PostgresJS driver as described in Neon's official Node.js docs. For Cloudflare Workers example, see Drizzle's Neon Cloudflare Worker example.

package/lovely-docs/drizzle-orm/connect-nile.md

@@ -0,0 +1,84 @@
+## Nile Integration
+
+Nile is PostgreSQL re-engineered for multi-tenant apps. Use any Drizzle PostgreSQL driver (e.g., node-postgres).
+
+### Installation
+```
+npm install drizzle-orm postgres
+npm install -D drizzle-kit
+```
+
+### Basic Setup
+```typescript
+import { drizzle } from 'drizzle-orm/node-postgres'
+const db = drizzle(process.env.NILEDB_URL);
+const response = await db.select().from(...);
+```
+
+Or with existing driver:
+```typescript
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const db = drizzle({ client: pool });
+```
+
+### Virtual Tenant Databases
+
+Nile provides virtual tenant databases. Set tenant context via transaction to isolate queries to that tenant:
+
+```typescript
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { sql } from 'drizzle-orm';
+
+const db = drizzle(process.env.NILEDB_URL);
+
+function tenantDB<T>(tenantId: string, cb: (tx: any) => T | Promise<T>): Promise<T> {
+  return db.transaction(async (tx) => {
+    if (tenantId) {
+      await tx.execute(sql`set local nile.tenant_id = '${sql.raw(tenantId)}'`);
+    }
+    return cb(tx);
+  }) as Promise<T>;
+}
+
+const tenantId = '01943e56-16df-754f-a7b6-6234c368b400'
+const response = await tenantDB(tenantId, async (tx) => {
+    return await tx.select().from(todosTable);
+});
+```
+
+### AsyncLocalStorage Pattern
+
+For web frameworks supporting AsyncLocalStorage, populate tenant ID via middleware:
+
+```typescript
+import { AsyncLocalStorage } from "async_hooks";
+
+export const tenantContext = new AsyncLocalStorage<string | undefined>();
+
+export function tenantDB<T>(cb: (tx: any) => T | Promise<T>): Promise<T> {
+  return db.transaction(async (tx) => {
+    const tenantId = tenantContext.getStore();
+    if (tenantId) {
+      await tx.execute(sql`set local nile.tenant_id = '${sql.raw(tenantId)}'`);
+    }
+    return cb(tx);
+  }) as Promise<T>;
+}
+```
+
+Middleware setup:
+```typescript
+app.use("/api/tenants/:tenantId/*", async (c, next) => {
+  const tenantId = c.req.param("tenantId");
+  return tenantContext.run(tenantId, () => next());
+});
+
+app.get("/api/tenants/:tenantId/todos", async (c) => {
+    const todos = await tenantDB(async (tx) => {
+      return await tx.select({...}).from(todoSchema);
+    });
+    return c.json(todos);
+});
+```

package/lovely-docs/drizzle-orm/connect-pglite.md

@@ -0,0 +1,39 @@
+## PGlite Integration
+
+PGlite is a WASM Postgres build packaged as a TypeScript client library that runs Postgres in the browser, Node.js, and Bun without external dependencies. It's 2.6mb gzipped and uses native WASM instead of a Linux VM. Supports ephemeral in-memory databases or persistence to the file system (Node/Bun) or indexedDB (Browser).
+
+### Installation
+
+```
+npm install drizzle-orm @electric-sql/pglite
+npm install -D drizzle-kit
+```
+
+### Usage
+
+In-memory database:
+```typescript
+import { drizzle } from 'drizzle-orm/pglite';
+const db = drizzle();
+await db.select().from(...);
+```
+
+With file system persistence:
+```typescript
+const db = drizzle('path-to-dir');
+```
+
+With advanced configuration:
+```typescript
+const db = drizzle({ connection: { dataDir: 'path-to-dir' }});
+```
+
+Using an existing PGlite client:
+```typescript
+import { PGlite } from '@electric-sql/pglite';
+import { drizzle } from 'drizzle-orm/pglite';
+
+const client = new PGlite();
+const db = drizzle({ client });
+await db.select().from(users);
+```

package/lovely-docs/drizzle-orm/connect-planetscale.md

@@ -0,0 +1,37 @@
+## PlanetScale Integration
+
+PlanetScale is a serverless MySQL platform. Drizzle ORM provides HTTP access to PlanetScale via the `drizzle-orm/planetscale-serverless` package (using PlanetScale's `database-js` driver), suitable for both serverless and traditional environments. TCP access via `mysql2` driver is also available.
+
+### Installation
+```
+npm install drizzle-orm @planetscale/database
+npm install -D drizzle-kit
+```
+
+### Basic Usage
+Initialize with connection credentials:
+```typescript
+import { drizzle } from "drizzle-orm/planetscale-serverless";
+
+const db = drizzle({ connection: {
+  host: process.env["DATABASE_HOST"],
+  username: process.env["DATABASE_USERNAME"],
+  password: process.env["DATABASE_PASSWORD"],
+}});
+
+const response = await db.select().from(...)
+```
+
+Or provide an existing PlanetScale client:
+```typescript
+import { drizzle } from "drizzle-orm/planetscale-serverless";
+import { Client } from "@planetscale/database";
+
+const client = new Client({
+  host: process.env["DATABASE_HOST"],
+  username: process.env["DATABASE_USERNAME"],
+  password: process.env["DATABASE_PASSWORD"],
+});
+
+const db = drizzle({ client });
+```

package/lovely-docs/drizzle-orm/connect-prisma-postgres.md

@@ -0,0 +1,48 @@
+## Connecting to Prisma Postgres
+
+Prisma Postgres is a serverless PostgreSQL database built on unikernels with a large free tier, operation-based pricing, and no cold starts.
+
+### Installation
+
+Choose between two PostgreSQL drivers:
+
+**node-postgres (pg):**
+```bash
+npm install drizzle-orm pg
+npm install -D drizzle-kit
+```
+
+**postgres.js:**
+```bash
+npm install drizzle-orm postgres
+npm install -D drizzle-kit
+```
+
+### Setup and Query
+
+**Using node-postgres:**
+```typescript
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+const db = drizzle({ client: pool });
+const result = await db.execute('select 1');
+```
+
+**Using postgres.js:**
+```typescript
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+
+const queryClient = postgres(process.env.DATABASE_URL);
+const db = drizzle({ client: queryClient });
+const result = await db.execute('select 1');
+```
+
+### Notes
+
+- Prisma Postgres also offers a serverless driver that will be supported in Drizzle ORM in the future
+- Prerequisites: familiarity with database connection basics, Prisma Postgres account, and PostgreSQL drivers documentation

package/lovely-docs/drizzle-orm/connect-sqlite-cloud.md

@@ -0,0 +1,29 @@
+## SQLite Cloud Integration
+
+SQLite Cloud is a managed, distributed relational database system built on SQLite.
+
+### Installation
+```
+drizzle-orm@beta @sqlitecloud/drivers
+-D drizzle-kit@beta
+```
+
+### Basic Usage
+Initialize with connection string:
+```typescript
+import { drizzle } from 'drizzle-orm/sqlite-cloud';
+const db = drizzle(process.env.SQLITE_CLOUD_CONNECTION_STRING);
+const result = await db.execute('select 1');
+```
+
+Or provide your own driver instance:
+```typescript
+import { Database } from '@sqlitecloud/drivers';
+import { drizzle } from 'drizzle-orm/sqlite-cloud';
+
+const client = new Database(process.env.SQLITE_CLOUD_CONNECTION_STRING!);
+const db = drizzle({ client });
+const result = await db.execute('select 1');
+```
+
+Two initialization patterns: pass connection string directly to `drizzle()`, or instantiate `Database` client first and pass it via `{ client }` option.

package/lovely-docs/drizzle-orm/connect-supabase.md

@@ -0,0 +1,45 @@
+## Supabase Integration
+
+Supabase is an open source Firebase alternative for building secure and performant Postgres backends with minimal configuration.
+
+### Installation
+
+```
+npm install drizzle-orm postgres
+npm install -D drizzle-kit
+```
+
+### Basic Setup
+
+```typescript
+import { drizzle } from 'drizzle-orm/postgres-js'
+
+const db = drizzle(process.env.DATABASE_URL);
+const allUsers = await db.select().from(...);
+```
+
+### With Existing Driver
+
+```typescript
+import { drizzle } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+
+const client = postgres(process.env.DATABASE_URL)
+const db = drizzle({ client });
+const allUsers = await db.select().from(...);
+```
+
+### Connection Pooling Configuration
+
+When using Supabase's connection pooler in "Transaction" pool mode, disable prepared statements:
+
+```typescript
+import { drizzle } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+
+const client = postgres(process.env.DATABASE_URL, { prepare: false })
+const db = drizzle({ client });
+const allUsers = await db.select().from(...);
+```
+
+Use the Connection Pooler for serverless environments and Direct Connection for long-running servers.

package/lovely-docs/drizzle-orm/connect-tidb-serverless.md

@@ -0,0 +1,35 @@
+## TiDB Serverless Integration
+
+TiDB Serverless is a fully-managed, autonomous DBaaS with split-second cluster provisioning and consumption-based pricing. It's compatible with MySQL and provides an HTTP driver for edge environments, natively supported by Drizzle ORM.
+
+### Installation
+
+```
+npm install drizzle-orm @tidbcloud/serverless
+npm install -D drizzle-kit
+```
+
+### Basic Setup
+
+Initialize with connection URL:
+```typescript
+import { drizzle } from 'drizzle-orm/tidb-serverless';
+
+const db = drizzle({ connection: { url: process.env.TIDB_URL }});
+const response = await db.select().from(...);
+```
+
+Or provide your own driver instance:
+```typescript
+import { connect } from '@tidbcloud/serverless';
+import { drizzle } from 'drizzle-orm/tidb-serverless';
+
+const client = connect({ url: process.env.TIDB_URL });
+const db = drizzle({ client });
+```
+
+### Prerequisites
+- Database connection basics with Drizzle
+- TiDB database account
+- TiDB HTTP Driver
+- Drizzle MySQL drivers knowledge

package/lovely-docs/drizzle-orm/connect-turso-database.md

@@ -0,0 +1,28 @@
+## Turso Database Integration
+
+Turso is a small database designed for the AI age. To connect Drizzle ORM to Turso:
+
+**Installation:**
+```
+npm install drizzle-orm@beta @tursodatabase/database
+npm install -D drizzle-kit@beta
+```
+
+**Basic usage - direct connection:**
+```typescript
+import { drizzle } from 'drizzle-orm/tursodatabase/database';
+const db = drizzle('sqlite.db');
+const result = await db.execute('select 1');
+```
+
+**Using existing driver instance:**
+```typescript
+import { Database } from '@tursodatabase/drivers';
+import { drizzle } from 'drizzle-orm/tursodatabase/database';
+
+const client = new Database('sqlite.db');
+const db = drizzle({ client });
+const result = await db.execute('select 1');
+```
+
+Prerequisites: familiarity with database connection basics in Drizzle, and knowledge of Turso Database and its JavaScript driver.