@lunarhue/expo-wa-sqlite 0.0.1

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

@@ -0,0 +1,69 @@
+## Headless TypeScript ORM
+
+Drizzle is a headless TypeScript ORM designed to let you build projects your way without forcing a specific structure. Unlike traditional data frameworks, Drizzle doesn't require building projects around it.
+
+### Core Philosophy
+
+**SQL-like API**: If you know SQL, you know Drizzle. The library embraces SQL rather than abstracting it away, eliminating the double learning curve of learning both SQL and a framework API.
+
+**Relational Query API**: For common scenarios where SQL-like queries aren't optimal, Drizzle provides a Queries API for fetching nested relational data conveniently. Drizzle always outputs exactly 1 SQL query, making it serverless-friendly.
+
+### Key Features
+
+- **Dual Query APIs**: Both SQL-like and relational query interfaces
+- **Schema Definition**: Define and manage database schemas in TypeScript
+- **Automatic Migrations**: Generate migrations from schema changes
+- **Zero Dependencies**: 31KB slim library, serverless-ready by design
+- **Multi-Database Support**: PostgreSQL, MySQL, SQLite, SingleStore with native driver support
+- **Type-Safe**: Full TypeScript support
+
+### Examples
+
+Schema definition:
+```typescript
+export const countries = pgTable('countries', {
+  id: serial('id').primaryKey(),
+  name: varchar('name', { length: 256 }),
+});
+
+export const cities = pgTable('cities', {
+  id: serial('id').primaryKey(),
+  name: varchar('name', { length: 256 }),
+  countryId: integer('country_id').references(() => countries.id),
+});
+```
+
+SQL-like query:
+```typescript
+await db
+  .select()
+  .from(countries)
+  .leftJoin(cities, eq(cities.countryId, countries.id))
+  .where(eq(countries.id, 10))
+```
+
+Relational query:
+```typescript
+const result = await db.query.users.findMany({
+  with: {
+    posts: true
+  },
+});
+```
+
+Generated migration:
+```sql
+CREATE TABLE IF NOT EXISTS "countries" (
+  "id" serial PRIMARY KEY NOT NULL,
+  "name" varchar(256)
+);
+
+CREATE TABLE IF NOT EXISTS "cities" (
+  "id" serial PRIMARY KEY NOT NULL,
+  "name" varchar(256),
+  "country_id" integer
+);
+
+ALTER TABLE "cities" ADD CONSTRAINT "cities_country_id_countries_id_fk" 
+FOREIGN KEY ("country_id") REFERENCES "countries"("id");
+```

package/lovely-docs/drizzle-orm/postgresql-setup.md

@@ -0,0 +1,71 @@
+## PostgreSQL Setup
+
+Drizzle supports PostgreSQL via two drivers: `node-postgres` (pg) and `postgres.js`.
+
+### Driver Differences
+- **node-postgres**: Can install `pg-native` for ~10% speed boost; supports per-query type parsers without global patching
+- **postgres.js**: Uses prepared statements by default (may need to opt out in AWS environments)
+
+### node-postgres Setup
+
+Install packages:
+```
+drizzle-orm pg
+-D drizzle-kit @types/pg
+```
+
+Initialize with connection string:
+```typescript
+import { drizzle } from 'drizzle-orm/node-postgres';
+const db = drizzle(process.env.DATABASE_URL);
+const result = await db.execute('select 1');
+```
+
+With config options:
+```typescript
+const db = drizzle({ 
+  connection: { 
+    connectionString: process.env.DATABASE_URL,
+    ssl: true
+  }
+});
+```
+
+With existing Pool:
+```typescript
+import { Pool } from "pg";
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const db = drizzle({ client: pool });
+```
+
+### postgres.js Setup
+
+Install packages:
+```
+drizzle-orm postgres
+-D drizzle-kit
+```
+
+Initialize with connection string:
+```typescript
+import { drizzle } from 'drizzle-orm/postgres-js';
+const db = drizzle(process.env.DATABASE_URL);
+const result = await db.execute('select 1');
+```
+
+With config options:
+```typescript
+const db = drizzle({ 
+  connection: { 
+    url: process.env.DATABASE_URL, 
+    ssl: true 
+  }
+});
+```
+
+With existing client:
+```typescript
+import postgres from 'postgres';
+const queryClient = postgres(process.env.DATABASE_URL);
+const db = drizzle({ client: queryClient });
+```

package/lovely-docs/drizzle-orm/postgresql_extensions.md

@@ -0,0 +1,93 @@
+## pg_vector
+
+Vector similarity search extension for PostgreSQL. Store vectors alongside relational data with support for exact and approximate nearest neighbor search, multiple vector types (single-precision, half-precision, binary, sparse), and distance metrics (L2, inner product, cosine, L1, Hamming, Jaccard).
+
+**Column Types:**
+```ts
+const table = pgTable('table', {
+    embedding: vector({ dimensions: 3 })
+})
+```
+
+**Indexes:**
+```ts
+const table = pgTable('items', {
+    embedding: vector({ dimensions: 3 })
+}, (table) => [
+  index('l2_index').using('hnsw', table.embedding.op('vector_l2_ops')),
+  index('ip_index').using('hnsw', table.embedding.op('vector_ip_ops')),
+  index('cosine_index').using('hnsw', table.embedding.op('vector_cosine_ops')),
+  index('l1_index').using('hnsw', table.embedding.op('vector_l1_ops')),
+  index('hamming_index').using('hnsw', table.embedding.op('bit_hamming_ops')),
+  index('jaccard_index').using('hnsw', table.embedding.op('bit_jaccard_ops'))
+])
+```
+
+**Helper Functions:**
+```ts
+import { l2Distance, l1Distance, innerProduct, cosineDistance, hammingDistance, jaccardDistance } from 'drizzle-orm'
+
+l2Distance(table.column, [3, 1, 2]) // <->
+l1Distance(table.column, [3, 1, 2]) // <+>
+innerProduct(table.column, [3, 1, 2]) // <#>
+cosineDistance(table.column, [3, 1, 2]) // <=>
+hammingDistance(table.column, '101') // <~>
+jaccardDistance(table.column, '101') // <%>
+```
+
+Custom distance functions can be created by replicating the pattern:
+```ts
+export function l2Distance(
+  column: SQLWrapper | AnyColumn,
+  value: number[] | string[] | TypedQueryBuilder<any> | string,
+): SQL {
+  if (is(value, TypedQueryBuilder<any>) || typeof value === 'string') {
+    return sql`${column} <-> ${value}`;
+  }
+  return sql`${column} <-> ${JSON.stringify(value)}`;
+}
+```
+
+**Query Examples:**
+```ts
+// Nearest neighbors
+db.select().from(items).orderBy(l2Distance(items.embedding, [3,1,2])).limit(5)
+
+// Distance calculation
+db.select({ distance: l2Distance(items.embedding, [3,1,2]) }).from(items)
+
+// Subquery distance
+const subquery = db.select({ embedding: items.embedding }).from(items).where(eq(items.id, 1));
+db.select().from(items).orderBy(l2Distance(items.embedding, subquery)).limit(5)
+
+// Computed distance
+db.select({ innerProduct: sql`(${innerProduct(items.embedding, [3,1,2])}) * -1` }).from(items)
+```
+
+## PostGIS
+
+Geospatial extension for PostgreSQL. Adds support for storing, indexing, and querying geographic data.
+
+**Column Types:**
+```ts
+const items = pgTable('items', {
+  geo: geometry('geo', { type: 'point' }),
+  geoObj: geometry('geo_obj', { type: 'point', mode: 'xy' }),
+  geoSrid: geometry('geo_options', { type: 'point', mode: 'xy', srid: 4000 }),
+});
+```
+
+**Mode:** `tuple` (default, maps to [x,y]) or `xy` (maps to {x, y} object)
+
+**Type:** Predefined `point` type available; any string can be used for other PostGIS types
+
+**Indexes:**
+```ts
+const table = pgTable('table', {
+  geo: geometry({ type: 'point' }),
+}, (table) => [
+  index('custom_idx').using('gist', table.geo)
+])
+```
+
+Note: Use `extensionsFilters` in drizzle config to exclude PostGIS tables from introspect/push commands.

package/lovely-docs/drizzle-orm/prepared-statements.md

@@ -0,0 +1,77 @@
+## Query Performance with Prepared Statements
+
+Drizzle ORM is a thin TypeScript layer on top of SQL with minimal overhead. To achieve near-zero overhead, use prepared statements.
+
+### How Query Execution Works
+When running a query:
+1. Query builder configurations are concatenated into an SQL string
+2. String and parameters are sent to the database driver
+3. Driver compiles SQL to binary executable format and sends to database
+
+With prepared statements, SQL concatenation happens once on the Drizzle side, allowing the database driver to reuse the precompiled binary SQL instead of parsing the query repeatedly. This provides extreme performance benefits, especially for large SQL queries.
+
+Different database drivers support prepared statements differently. Drizzle ORM can sometimes outperform even the better-sqlite3 driver.
+
+### Prepared Statement Usage
+
+**PostgreSQL:**
+```typescript
+const db = drizzle(...);
+const prepared = db.select().from(customers).prepare("statement_name");
+const res1 = await prepared.execute();
+const res2 = await prepared.execute();
+```
+
+**MySQL:**
+```typescript
+const prepared = db.select().from(customers).prepare();
+const res1 = await prepared.execute();
+const res2 = await prepared.execute();
+```
+
+**SQLite:**
+```typescript
+const prepared = db.select().from(customers).prepare();
+const res1 = prepared.all();
+const res2 = prepared.all();
+```
+
+**SingleStore:**
+```typescript
+const prepared = db.select().from(customers).prepare();
+const res1 = await prepared.execute();
+const res2 = await prepared.execute();
+```
+
+### Placeholders for Dynamic Values
+
+Use `sql.placeholder(...)` to embed dynamic runtime values:
+
+```typescript
+import { sql } from "drizzle-orm";
+
+// Simple placeholder
+const p1 = db
+  .select()
+  .from(customers)
+  .where(eq(customers.id, sql.placeholder('id')))
+  .prepare("p1");
+
+await p1.execute({ id: 10 }); // SELECT * FROM customers WHERE id = 10
+await p1.execute({ id: 12 }); // SELECT * FROM customers WHERE id = 12
+
+// Complex placeholder with SQL functions
+const p2 = db
+  .select()
+  .from(customers)
+  .where(sql`lower(${customers.name}) like ${sql.placeholder('name')}`)
+  .prepare("p2");
+
+await p2.execute({ name: '%an%' }); // SELECT * FROM customers WHERE lower(name) like '%an%'
+```
+
+For SQLite, use `.get()` and `.all()` instead of `.execute()`:
+```typescript
+p1.get({ id: 10 });
+p2.all({ name: '%an%' });
+```

package/lovely-docs/drizzle-orm/prisma-extension.md

@@ -0,0 +1,46 @@
+## Drizzle Extension for Prisma
+
+Allows using Drizzle alongside Prisma in existing projects by extending the Prisma client with Drizzle API, reusing the same DB connection.
+
+### Setup
+
+1. Install dependencies:
+```bash
+npm install drizzle-orm
+npm install -D drizzle-prisma-generator
+```
+
+2. Add generator to `schema.prisma`:
+```prisma
+generator drizzle {
+  provider = "drizzle-prisma-generator"
+  output   = "./drizzle"
+}
+```
+
+3. Generate schema:
+```bash
+prisma generate
+```
+
+4. Extend Prisma client (PostgreSQL example; also available for MySQL and SQLite):
+```ts
+import { PrismaClient } from '@prisma/client';
+import { drizzle } from 'drizzle-orm/prisma/pg';
+
+const prisma = new PrismaClient().$extends(drizzle());
+```
+
+5. Use Drizzle queries via `prisma.$drizzle`:
+```ts
+import { User } from './drizzle';
+
+await prisma.$drizzle.insert().into(User).values({ email: 'sorenbs@drizzle.team', name: 'Søren' });
+const users = await prisma.$drizzle.select().from(User);
+```
+
+### Limitations
+
+- Relational queries not supported (Prisma driver limitation with array format results)
+- SQLite: `.values()` not supported
+- Prepared statements: `.prepare()` builds SQL on Drizzle side only, no Prisma API for prepared queries

package/lovely-docs/drizzle-orm/pull.md

@@ -0,0 +1,134 @@
+## Purpose
+`drizzle-kit pull` introspects an existing database schema and generates a TypeScript Drizzle schema file (`schema.ts`). It's designed for database-first migration approaches where the database schema is managed outside the TypeScript project.
+
+## How It Works
+1. Pulls database schema (DDL) from an existing database
+2. Generates `schema.ts` file with Drizzle schema definitions
+3. Saves output to the `out` folder (default: `./drizzle`)
+
+Example flow:
+```
+Database: CREATE TABLE "users" ("id" SERIAL PRIMARY KEY, "name" TEXT, "email" TEXT UNIQUE);
+↓
+Generated schema.ts:
+import * as p from "drizzle-orm/pg-core";
+export const users = p.pgTable("users", {
+  id: p.serial().primaryKey(),
+  name: p.text(),
+  email: p.text().unique(),
+});
+```
+
+## Configuration
+Requires `dialect` and database connection info via config file or CLI:
+
+**Config file approach:**
+```ts
+// drizzle.config.ts
+import { defineConfig } from "drizzle-kit";
+export default defineConfig({
+  dialect: "postgresql",
+  dbCredentials: {
+    url: "postgresql://user:password@host:port/dbname",
+  },
+});
+```
+```shell
+npx drizzle-kit pull
+```
+
+**CLI approach:**
+```shell
+npx drizzle-kit pull --dialect=postgresql --url=postgresql://user:password@host:port/dbname
+```
+
+## Multiple Config Files
+Support for multiple configuration files in one project for different database stages:
+```shell
+npx drizzle-kit pull --config=drizzle-dev.config.ts
+npx drizzle-kit pull --config=drizzle-prod.config.ts
+```
+
+## Database Driver Specification
+Drizzle Kit automatically picks the database driver based on `dialect`. For exceptions like AWS Data API, PGLite, and Cloudflare D1 HTTP, explicitly specify the `driver` param:
+
+```ts
+// AWS Data API
+export default defineConfig({
+  dialect: "postgresql",
+  driver: "aws-data-api",
+  dbCredentials: {
+    database: "database",
+    resourceArn: "resourceArn",
+    secretArn: "secretArn",
+  },
+});
+
+// PGLite
+export default defineConfig({
+  dialect: "postgresql",
+  driver: "pglite",
+  dbCredentials: {
+    url: ":memory:" // or "./database/"
+  },
+});
+
+// Cloudflare D1 HTTP
+export default defineConfig({
+  dialect: "sqlite",
+  driver: "d1-http",
+  dbCredentials: {
+    accountId: "accountId",
+    databaseId: "databaseId",
+    token: "token",
+  },
+});
+```
+
+Note: Expo SQLite and OP SQLite cannot be used with `pull` as they are on-device databases.
+
+## Filtering Tables, Schemas, and Extensions
+Configure which tables, schemas, and extensions to manage:
+
+```ts
+export default defineConfig({
+  dialect: "postgresql",
+  schema: "./src/schema.ts",
+  dbCredentials: {
+    url: "postgresql://user:password@host:port/dbname",
+  },
+  extensionsFilters: ["postgis"],
+  schemaFilter: ["public"],
+  tablesFilter: ["*"],
+});
+```
+
+| Option | Description |
+|--------|-------------|
+| `tablesFilter` | Glob-based table names filter, e.g. `["users", "user_info"]` or `"user*"`. Default: `"*"` |
+| `schemaFilter` | Schema names filter, e.g. `["public", "drizzle"]`. Default: `["public"]` |
+| `extensionsFilters` | List of installed database extensions, e.g. `["postgis"]`. Default: `[]` |
+
+## CLI Options
+```shell
+npx drizzle-kit pull --dialect=postgresql --url=postgresql://user:password@host:port/dbname
+npx drizzle-kit pull --dialect=postgresql --driver=pglite --url=database/
+npx drizzle-kit pull --dialect=postgresql --tablesFilter='user*' --extensionsFilters=postgis --url=postgresql://user:password@host:port/dbname
+```
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| `dialect` | Yes | Database dialect (postgresql, mysql, sqlite, etc.) |
+| `driver` | No | Driver exceptions (aws-data-api, pglite, d1-http) |
+| `out` | No | Migrations output folder path, default: `./drizzle` |
+| `url` | No | Database connection string |
+| `user` | No | Database user |
+| `password` | No | Database password |
+| `host` | No | Host |
+| `port` | No | Port |
+| `database` | No | Database name |
+| `config` | No | Configuration file path, default: `drizzle.config.ts` |
+| `introspect-casing` | No | Strategy for JS keys creation: `preserve` or `camel` |
+| `tablesFilter` | No | Table name filter |
+| `schemaFilter` | No | Schema name filter, default: `["public"]` |
+| `extensionsFilters` | No | Database extensions internal database filters |

package/lovely-docs/drizzle-orm/push.md

@@ -0,0 +1,129 @@
+## Overview
+`drizzle-kit push` applies schema changes directly to the database without generating SQL files. It implements a code-first migration approach by reading your Drizzle schema, comparing it to the database schema, generating SQL migrations, and applying them automatically.
+
+## How It Works
+1. Read Drizzle schema file(s) and create a JSON snapshot
+2. Introspect current database schema
+3. Generate SQL migrations based on differences
+4. Apply migrations to the database
+
+## Configuration
+Configure via `drizzle.config.ts` or CLI options. Required: `dialect`, `schema` path, and database connection (`url` or `user:password@host:port/db`).
+
+```ts
+// drizzle.config.ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "postgresql",
+  schema: "./src/schema.ts",
+  dbCredentials: {
+    url: "postgresql://user:password@host:port/dbname",
+  },
+});
+```
+
+```shell
+npx drizzle-kit push
+```
+
+Or via CLI:
+```shell
+npx drizzle-kit push --dialect=postgresql --schema=./src/schema.ts --url=postgresql://user:password@host:port/dbname
+```
+
+## Schema Files
+Use glob patterns for single or multiple schema files:
+```ts
+schema: "./src/schema.ts"           // single file
+schema: "./src/**/*.schema.ts"       // multiple files
+```
+
+## Multiple Config Files
+Support different database stages or databases:
+```shell
+npx drizzle-kit push --config=drizzle-dev.config.ts
+npx drizzle-kit push --config=drizzle-prod.config.ts
+```
+
+## Database Drivers
+Drizzle Kit automatically picks the driver based on `dialect`. For exceptions like `aws-data-api`, `pglight`, and `d1-http`, explicitly specify the `driver` parameter.
+
+Note: Expo SQLite and OP SQLite (on-device databases) don't support `push`; use embedded migrations instead.
+
+## Filtering Tables, Schemas, and Extensions
+```ts
+export default defineConfig({
+  dialect: "postgresql",
+  schema: "./src/schema.ts",
+  dbCredentials: { url: "..." },
+  tablesFilter: ["*"],              // glob-based table filter, default "*"
+  schemaFilter: ["public"],          // schema names, default ["public"]
+  extensionsFilters: ["postgis"],    // installed extensions to ignore
+});
+```
+
+## CLI-Only Options
+- `--verbose`: Print all SQL statements before execution
+- `--strict`: Ask for approval before executing SQL
+- `--force`: Auto-accept data-loss statements
+
+```shell
+npx drizzle-kit push --strict --verbose --force
+```
+
+## All Configuration Options
+| Option | Required | Description |
+|--------|----------|-------------|
+| `dialect` | yes | Database dialect (postgresql, mysql, sqlite, etc.) |
+| `schema` | yes | Path to schema file(s) or folder |
+| `driver` | | Driver exception (aws-data-api, pglight, d1-http) |
+| `tablesFilter` | | Table name filter |
+| `schemaFilter` | | Schema names, default `["public"]` |
+| `extensionsFilters` | | Database extensions to ignore |
+| `url` | | Database connection string |
+| `user` | | Database user |
+| `password` | | Database password |
+| `host` | | Host |
+| `port` | | Port |
+| `database` | | Database name |
+| `config` | | Config file path, default `drizzle.config.ts` |
+
+## Example
+```ts
+// drizzle.config.ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "postgresql",
+  schema: "./src/schema.ts",
+  dbCredentials: {
+    url: "postgresql://user:password@host:port/dbname"
+  },
+});
+```
+
+```ts
+// src/schema.ts
+import * as p from "drizzle-orm/pg-core";
+
+export const users = p.pgTable("users", {
+  id: p.serial().primaryKey(),
+  name: p.text(),
+})
+```
+
+```shell
+npx drizzle-kit push
+```
+
+Generates and applies:
+```sql
+CREATE TABLE "users"(
+  id serial primary key,
+  name text
+)
+```
+
+## Use Cases
+Best for rapid prototyping and production applications. Pairs well with blue/green deployments and serverless databases (Planetscale, Neon, Turso).

package/lovely-docs/drizzle-orm/queries-and-crud.md

@@ -0,0 +1,72 @@
+## SQL-like Syntax
+
+Drizzle provides SQL-like query syntax that mirrors standard SQL, minimizing learning curve. You write queries that look like SQL and know exactly what SQL will be generated.
+
+**Select with joins:**
+```typescript
+await db
+  .select()
+  .from(posts)
+  .leftJoin(comments, eq(posts.id, comments.post_id))
+  .where(eq(posts.id, 10))
+```
+
+**Insert:**
+```typescript
+await db.insert(users).values({ email: 'user@gmail.com' })
+```
+
+**Update:**
+```typescript
+await db.update(users)
+  .set({ email: 'user@gmail.com' })
+  .where(eq(users.id, 1))
+```
+
+**Delete:**
+```typescript
+await db.delete(users).where(eq(users.id, 1))
+```
+
+Supports select, insert, update, delete, aliases, WITH clauses, subqueries, and prepared statements.
+
+## Relational Queries API
+
+For common scenarios with nested/relational data, use the Queries API for more convenient and performant fetching without manual joins or data mapping. Always outputs exactly one SQL query, safe for serverless databases.
+
+```typescript
+const result = await db.query.users.findMany({
+  with: {
+    posts: true
+  },
+});
+```
+
+## Advanced Composition
+
+Queries can be composed and partitioned flexibly:
+
+**Compose WHERE filters independently:**
+```typescript
+async function getProductsBy({ name, category, maxPrice }) {
+  const filters: SQL[] = [];
+  if (name) filters.push(ilike(products.name, name));
+  if (category) filters.push(eq(products.category, category));
+  if (maxPrice) filters.push(lte(products.price, maxPrice));
+  return db.select().from(products).where(and(...filters));
+}
+```
+
+**Separate subqueries into variables:**
+```typescript
+const subquery = db
+  .select()
+  .from(internalStaff)
+  .leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+  .as('internal_staff');
+
+const mainQuery = await db
+  .select()
+  .from(ticket)
+  .leftJoin(subquery, eq(subquery.internal_staff.userId, ticket.staffId));
+```