@lunarhue/expo-wa-sqlite 0.0.1

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

@@ -0,0 +1,60 @@
+## Turso Cloud Integration
+
+Turso is a libSQL-powered edge SQLite database as a service. Drizzle ORM natively supports the libSQL driver.
+
+### Installation
+```
+npm install drizzle-orm @libsql/client
+npm install -D drizzle-kit
+```
+
+### Driver Initialization
+Drizzle supports all `@libsql/client` driver variations. Initialize with:
+
+**Node.js:**
+```typescript
+import { drizzle } from 'drizzle-orm/libsql';
+import { createClient } from '@libsql/client';
+
+const client = createClient({ 
+  url: process.env.DATABASE_URL,
+  authToken: process.env.DATABASE_AUTH_TOKEN
+});
+
+const db = drizzle({ client });
+```
+
+**Web:**
+```typescript
+import { drizzle } from 'drizzle-orm/libsql/web';
+import { createClient } from '@libsql/client/web';
+
+const client = createClient({ 
+  url: process.env.DATABASE_URL,
+  authToken: process.env.DATABASE_AUTH_TOKEN
+});
+
+const db = drizzle({ client });
+```
+
+Alternatively, pass connection config directly:
+```typescript
+const db = drizzle({ connection: {
+  url: process.env.DATABASE_URL, 
+  authToken: process.env.DATABASE_AUTH_TOKEN 
+}});
+```
+
+### Querying
+```typescript
+import * as s from 'drizzle-orm/sqlite-core';
+
+const users = s.sqliteTable("users", {
+  id: s.integer(),
+  name: s.text(),
+});
+
+const result = await db.select().from(users);
+```
+
+Drizzle mirrors SQLite query methods: `all()`, `get()`, `values()`, `run()`.

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

@@ -0,0 +1,37 @@
+## Vercel Postgres Integration
+
+Vercel Postgres is a serverless SQL database designed to integrate with Vercel Functions. Drizzle ORM natively supports both the `@vercel/postgres` serverless driver and standard PostgreSQL drivers (`postgres` or `pg`) for accessing Vercel Postgres.
+
+### Installation
+
+```
+drizzle-orm @vercel/postgres
+-D drizzle-kit
+```
+
+### Setup
+
+1. Set up a Vercel Postgres project according to official Vercel docs
+2. Initialize the driver and execute queries
+
+### Usage
+
+With default client:
+```typescript
+import { drizzle } from 'drizzle-orm/vercel-postgres';
+const db = drizzle();
+const result = await db.execute('select 1');
+```
+
+With existing driver:
+```typescript
+import { sql } from '@vercel/postgres';
+import { drizzle } from 'drizzle-orm/vercel-postgres';
+const db = drizzle({ client: sql });
+const result = await db.execute('select 1');
+```
+
+### Key Features
+
+- `@vercel/postgres` works in both serverful and serverless environments (including Cloudflare Workers) via websockets
+- For serverful environments, can use `@vercel/postgres` or direct `postgresql://` connection with `postgres` or `pg` drivers

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

@@ -0,0 +1,29 @@
+## Xata Integration
+
+Xata is a PostgreSQL database platform with features like instant copy-on-write branches, zero-downtime schema changes, data anonymization, and AI-powered performance monitoring.
+
+### Setup
+
+Install packages:
+```
+drizzle-orm postgres
+-D drizzle-kit
+```
+
+Initialize driver and query:
+```typescript
+import { drizzle } from 'drizzle-orm/postgres-js'
+
+const db = drizzle(process.env.DATABASE_URL);
+const allUsers = await db.select().from(...);
+```
+
+Or with existing postgres 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(...);
+```

package/lovely-docs/drizzle-orm/custom-migrations.md

@@ -0,0 +1,40 @@
+## Custom SQL Migrations
+
+Drizzle Kit allows you to generate empty migration files for writing custom SQL migrations that handle DDL alterations not yet supported by Drizzle Kit, or for data seeding operations.
+
+### Generating Custom Migrations
+
+Use the `--custom` flag with the generate command:
+
+```shell
+drizzle-kit generate --custom --name=seed-users
+```
+
+This creates a new migration file in the `drizzle` directory with a sequential number prefix:
+
+```plaintext
+📦 <project root>
+ ├ 📂 drizzle
+ │ ├ 📂 _meta
+ │ ├ 📜 0000_init.sql 
+ │ └ 📜 0001_seed-users.sql 
+ ├ 📂 src
+ └ …
+```
+
+### Writing Custom SQL
+
+Write your custom SQL directly in the generated migration file:
+
+```sql
+-- ./drizzle/0001_seed-users.sql
+INSERT INTO "users" ("name") VALUES('Dan');
+INSERT INTO "users" ("name") VALUES('Andrew');
+INSERT INTO "users" ("name") VALUES('Dandrew');
+```
+
+Custom migrations are executed using the `drizzle-kit migrate` command.
+
+### Future: JavaScript and TypeScript Migrations
+
+Support for running custom JavaScript and TypeScript migration/seeding scripts is planned for an upcoming release.

package/lovely-docs/drizzle-orm/custom-types.md

@@ -0,0 +1,137 @@
+## Defining Custom Types
+
+Custom types in Drizzle ORM are created using the `customType` function, which allows you to define database-specific data types with TypeScript type safety.
+
+### Core Concept
+
+The `customType` function accepts a generic type parameter with the following properties:
+- `data`: The TypeScript type for the column (e.g., `string`, `number`, `Date`)
+- `driverData`: (optional) The type the database driver uses internally
+- `config`: (optional) Configuration object type for the data type definition
+- `notNull`: (optional) Whether the type is not null by default
+- `default`: (optional) Whether the type has a default value
+
+### CustomTypeParams Interface
+
+The function receives a configuration object with:
+- `dataType(config?)`: Returns the SQL data type string (e.g., `'text'`, `'serial'`, `'varchar(256)'`)
+- `toDriver(value)`: (optional) Maps TypeScript value to driver format
+- `fromDriver(value)`: (optional) Maps driver value back to TypeScript format
+
+### Postgres Examples
+
+**Serial**
+```typescript
+import { customType } from 'drizzle-orm/pg-core';
+
+const customSerial = customType<{ data: number; notNull: true; default: true }>({
+  dataType() { return 'serial'; },
+});
+```
+
+**Text**
+```typescript
+const customText = customType<{ data: string }>({
+  dataType() { return 'text'; },
+});
+```
+
+**Boolean**
+```typescript
+const customBoolean = customType<{ data: boolean }>({
+  dataType() { return 'boolean'; },
+});
+```
+
+**JSONB with generic type**
+```typescript
+const customJsonb = <TData>(name: string) =>
+  customType<{ data: TData; driverData: string }>({
+    dataType() { return 'jsonb'; },
+    toDriver(value: TData): string { return JSON.stringify(value); },
+  })(name);
+```
+
+**Timestamp with config**
+```typescript
+const customTimestamp = customType<{
+  data: Date;
+  driverData: string;
+  config: { withTimezone: boolean; precision?: number };
+}>({
+  dataType(config) {
+    const precision = typeof config.precision !== 'undefined' ? ` (${config.precision})` : '';
+    return `timestamp${precision}${config.withTimezone ? ' with time zone' : ''}`;
+  },
+  fromDriver(value: string): Date { return new Date(value); },
+});
+```
+
+### MySQL Examples
+
+**Int**
+```typescript
+import { customType } from 'drizzle-orm/mysql-core';
+
+const customInt = customType<{ data: number; notNull: false; default: false }>({
+  dataType() { return 'int'; },
+});
+```
+
+**Text** (same as Postgres)
+
+**Boolean with driver mapping**
+```typescript
+const customBoolean = customType<{ data: boolean }>({
+  dataType() { return 'boolean'; },
+  fromDriver(value) { return typeof value === 'boolean' ? value : value === 1; },
+});
+```
+
+**JSON with generic type**
+```typescript
+const customJson = <TData>(name: string) =>
+  customType<{ data: TData; driverData: string }>({
+    dataType() { return 'json'; },
+    toDriver(value: TData): string { return JSON.stringify(value); },
+  })(name);
+```
+
+**Timestamp with fsp config**
+```typescript
+const customTimestamp = customType<{
+  data: Date;
+  driverData: string;
+  config: { fsp: number };
+}>({
+  dataType(config) {
+    const precision = typeof config.fsp !== 'undefined' ? ` (${config.fsp})` : '';
+    return `timestamp${precision}`;
+  },
+  fromDriver(value: string): Date { return new Date(value); },
+});
+```
+
+### Usage in Table Definition
+
+```typescript
+// Postgres
+const usersTable = pgTable('users', {
+  id: customSerial('id').primaryKey(),
+  name: customText('name').notNull(),
+  verified: customBoolean('verified').notNull().default(false),
+  jsonb: customJsonb<string[]>('jsonb'),
+  createdAt: customTimestamp('created_at', { withTimezone: true }).notNull().default(sql`now()`),
+});
+
+// MySQL
+const usersTable = mysqlTable('userstest', {
+  id: customInt('id').primaryKey(),
+  name: customText('name').notNull(),
+  verified: customBoolean('verified').notNull().default(false),
+  jsonb: customJson<string[]>('jsonb'),
+  createdAt: customTimestamp('created_at', { fsp: 2 }).notNull().default(sql`now()`),
+});
+```
+
+Custom types are used identically to built-in Drizzle ORM types once defined.

package/lovely-docs/drizzle-orm/database-connection-overview.md

@@ -0,0 +1,89 @@
+## Database Connection with Drizzle
+
+Drizzle ORM executes SQL queries through database drivers. The ORM creates a database instance that translates high-level queries into SQL and communicates with the database via the driver.
+
+### Basic Connection
+
+```ts
+import { drizzle } from "drizzle-orm/node-postgres"
+import { users } from "./schema"
+
+const db = drizzle(process.env.DATABASE_URL);
+const usersCount = await db.$count(users);
+```
+
+The query `db.$count(users)` translates to `select count(*) from users` and is executed through the node-postgres driver, returning `[{ count: 0 }]`.
+
+### Accessing the Driver Client
+
+Drizzle creates a driver instance internally, accessible via `db.$client`:
+
+```ts
+const db = drizzle(process.env.DATABASE_URL);
+const pool = db.$client;
+
+// Equivalent to manually creating:
+import { Pool } from "pg";
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const db = drizzle({ client: pool });
+```
+
+### Edge and Serverless Runtimes
+
+Drizzle supports multiple serverless database drivers:
+
+```ts
+// Neon HTTP
+import { drizzle } from "drizzle-orm/neon-http";
+const db = drizzle(process.env.DATABASE_URL);
+
+// Neon with websockets
+import { drizzle } from "drizzle-orm/neon-serverless";
+const db = drizzle(process.env.DATABASE_URL);
+
+// Vercel Postgres
+import { drizzle } from "drizzle-orm/vercel-postgres";
+const db = drizzle();
+
+// PlanetScale HTTP
+import { drizzle } from "drizzle-orm/planetscale";
+const db = drizzle(process.env.DATABASE_URL);
+
+// Cloudflare D1
+import { drizzle } from "drizzle-orm/d1";
+const db = drizzle({ connection: env.DB });
+```
+
+### Runtime-Specific Drivers
+
+```ts
+// Bun SQLite
+import { drizzle } from "drizzle-orm/bun-sqlite"
+const db = drizzle(); // in-memory
+const db = drizzle("./sqlite.db");
+
+// Expo SQLite
+import { drizzle } from "drizzle-orm/expo-sqlite";
+import { openDatabaseSync } from "expo-sqlite";
+const expo = openDatabaseSync("db.db");
+const db = drizzle(expo);
+```
+
+### Database Connection URL Format
+
+```
+postgresql://alex:AbC123dEf@ep-cool-darkness-123456.us-east-2.aws.neon.tech/dbname
+             └──┘ └───────┘ └─────────────────────────────────────────────┘ └────┘
+              ʌ    ʌ          ʌ                                              ʌ
+        role -│    │          │- hostname                                    │- database
+                   │
+                   │- password
+```
+
+### Available Drivers
+
+PostgreSQL: PostgreSQL, Neon, Vercel Postgres, Supabase, Xata, PGLite
+MySQL: MySQL, PlanetScale, TiDB
+SQLite: SQLite, Turso Cloud, Turso Database, Cloudflare D1, Bun SQLite, SQLite Cloud
+Native SQLite: Expo SQLite, OP SQLite, React Native SQLite
+Others: Drizzle Proxy

package/lovely-docs/drizzle-orm/database_setup_guides/bun-sql-existing.md

@@ -0,0 +1,59 @@
+## Setup Drizzle ORM with Bun SQL in an existing project
+
+**Prerequisites:**
+- dotenv for environment variables
+- Bun JavaScript toolkit
+- Bun SQL native bindings for PostgreSQL
+
+**Known Issue:** Bun v1.2.0 has concurrent statement execution issues that may cause errors when running multiple queries simultaneously.
+
+**Installation:**
+```bash
+npm install drizzle-orm dotenv
+npm install -D drizzle-kit @types/bun
+```
+
+**Setup Steps:**
+
+1. Create `.env` file with `DATABASE_URL` variable pointing to your PostgreSQL database
+
+2. Create `drizzle.config.ts`:
+```typescript
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+```
+
+3. Introspect existing database to generate schema:
+```bash
+drizzle-kit introspect:pg
+```
+
+4. Transfer generated schema to your actual schema file
+
+5. Connect to database in `src/index.ts`:
+```typescript
+import { drizzle } from 'drizzle-orm/bun';
+import { sql } from 'bun:sql';
+
+const db = drizzle(sql);
+```
+
+6. Query the database:
+```typescript
+const result = await db.query.users.findMany();
+```
+
+7. Run with Bun:
+```bash
+bun src/index.ts
+```
+
+8. (Optional) Update table schema and apply migrations with `drizzle-kit push:pg`
+
+9. (Optional) Query with new fields after schema updates

package/lovely-docs/drizzle-orm/database_setup_guides/bun-sqlite-existing.md

@@ -0,0 +1,48 @@
+## Setup Drizzle ORM with Bun:SQLite in an existing project
+
+**Prerequisites:**
+- dotenv - for environment variables
+- tsx - for running TypeScript files
+- bun - JavaScript all-in-one toolkit
+- bun:sqlite - native SQLite3 driver
+
+**Step 1: Install packages**
+```bash
+npm install drizzle-orm dotenv
+npm install -D drizzle-kit tsx @types/bun
+```
+
+**Step 2: Setup environment variables**
+Create a `.env` file with:
+```plaintext
+DB_FILE_NAME=mydb.sqlite
+```
+
+**Step 3: Setup Drizzle config file**
+Create `drizzle.config.ts` with SQLite dialect and reference the `DB_FILE_NAME` environment variable.
+
+**Step 4: Introspect your database**
+Run introspection to generate schema from existing SQLite database.
+
+**Step 5: Transfer introspected code to schema file**
+Move the generated schema code to your actual schema file.
+
+**Step 6: Connect Drizzle ORM to the database**
+Use bun:sqlite to establish connection in your application.
+
+**Step 7: Query the database**
+Write queries using the generated schema with bun-sqlite dialect.
+
+**Step 8: Run the script**
+```bash
+bun src/index.ts
+```
+
+**Step 9 (optional): Update table schema**
+Modify your schema definitions as needed.
+
+**Step 10 (optional): Apply changes to database**
+Run migrations to apply schema changes to the database.
+
+**Step 11 (optional): Query with new fields**
+Test queries with newly added schema fields.

package/lovely-docs/drizzle-orm/database_setup_guides/bun-sqlite-new.md

@@ -0,0 +1,34 @@
+## Setup Drizzle ORM with Bun and SQLite
+
+**Prerequisites:**
+- bun - JavaScript all-in-one toolkit
+- bun:sqlite - native high-performance SQLite3 driver
+
+**Step 1 - Install packages:**
+```bash
+npm install drizzle-orm
+npm install -D drizzle-kit @types/bun
+```
+
+**Step 2 - Setup connection variables:**
+Create environment variable `DB_FILE_NAME` with value like `mydb.sqlite`
+
+**Step 3 - Connect to database:**
+Use bun:sqlite to establish connection to the database file
+
+**Step 4 - Create a table:**
+Define schema using Drizzle ORM table definitions
+
+**Step 5 - Setup Drizzle config file:**
+Configure drizzle.config.ts with dialect set to 'sqlite' and reference the DB_FILE_NAME environment variable
+
+**Step 6 - Apply changes:**
+Run migrations to apply schema changes to the database
+
+**Step 7 - Seed and Query:**
+Write queries using Drizzle ORM to insert and retrieve data from the database
+
+**Step 8 - Run the script:**
+```bash
+bun src/index.ts
+```

package/lovely-docs/drizzle-orm/database_setup_guides/d1-new.md

@@ -0,0 +1,74 @@
+## Getting Started with Cloudflare D1
+
+Setup guide for using Drizzle ORM with Cloudflare D1 serverless SQL database.
+
+**Prerequisites:**
+- dotenv - environment variable management
+- tsx - TypeScript file runner
+- Cloudflare D1 - serverless SQL database
+- wrangler - Cloudflare CLI
+
+**Step 1: Install packages**
+Install drizzle-orm and required dependencies.
+
+**Step 2: Configure wrangler.toml**
+```toml
+name = "YOUR PROJECT NAME"
+main = "src/index.ts"
+compatibility_date = "2022-11-07"
+node_compat = true
+
+[[ d1_databases ]]
+binding = "DB"
+database_name = "YOUR DB NAME"
+database_id = "YOUR DB ID"
+migrations_dir = "drizzle"
+```
+
+**Step 3: Connect to database**
+```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>);
+  },
+};
+```
+
+**Step 4: Create a table**
+Define your schema (referenced from separate component).
+
+**Step 5: Setup drizzle.config.ts**
+```typescript
+import 'dotenv/config';
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  out: './drizzle',
+  schema: './src/db/schema.ts',
+  dialect: 'sqlite',
+  driver: 'd1-http',
+  dbCredentials: {
+    accountId: process.env.CLOUDFLARE_ACCOUNT_ID!,
+    databaseId: process.env.CLOUDFLARE_DATABASE_ID!,
+    token: process.env.CLOUDFLARE_D1_TOKEN!,
+  },
+});
+```
+
+**Step 6: Apply migrations**
+Run migrations to update database schema.
+
+**Step 7: Query the database**
+```typescript
+const db = drizzle(env.<BINDING_NAME>);
+const result = await db.select().from(users).all()
+return Response.json(result);
+```
+
+**Step 8: Run the application**
+Execute the index.ts file.