@lunarhue/expo-wa-sqlite 0.0.1

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

@@ -0,0 +1,79 @@
+## SQL Update
+
+Basic update with `.set()` and `.where()`:
+```typescript
+await db.update(users)
+  .set({ name: 'Mr. Dan' })
+  .where(eq(users.name, 'Dan'));
+```
+
+Keys in the set object must match column names. `undefined` values are ignored; pass `null` to set a column to null. SQL expressions can be passed as values:
+```typescript
+await db.update(users)
+  .set({ updatedAt: sql`NOW()` })
+  .where(eq(users.name, 'Dan'));
+```
+
+### Limit (MySQL, SQLite, SingleStore only)
+```typescript
+await db.update(usersTable).set({ verified: true }).limit(2);
+```
+
+### Order By
+```typescript
+import { asc, desc } from 'drizzle-orm';
+
+await db.update(usersTable).set({ verified: true }).orderBy(usersTable.name);
+await db.update(usersTable).set({ verified: true }).orderBy(desc(usersTable.name));
+await db.update(usersTable).set({ verified: true }).orderBy(usersTable.name, usersTable.name2);
+await db.update(usersTable).set({ verified: true }).orderBy(asc(usersTable.name), desc(usersTable.name2));
+```
+
+### Returning (PostgreSQL, SQLite only)
+```typescript
+const updatedUserId: { updatedId: number }[] = await db.update(users)
+  .set({ name: 'Mr. Dan' })
+  .where(eq(users.name, 'Dan'))
+  .returning({ updatedId: users.id });
+```
+
+### WITH clause (CTE)
+```typescript
+const averagePrice = db.$with('average_price').as(
+  db.select({ value: sql`avg(${products.price})`.as('value') }).from(products)
+);
+
+const result = await db.with(averagePrice)
+  .update(products)
+  .set({ cheap: true })
+  .where(lt(products.price, sql`(select * from ${averagePrice})`))
+  .returning({ id: products.id });
+```
+
+### Update ... FROM (PostgreSQL, SQLite only)
+Join other tables to compute which rows to update and their new values:
+```typescript
+await db
+  .update(users)
+  .set({ cityId: cities.id })
+  .from(cities)
+  .where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')));
+```
+
+With table aliases:
+```typescript
+const c = alias(cities, 'c');
+await db
+  .update(users)
+  .set({ cityId: c.id })
+  .from(c);
+```
+
+PostgreSQL only: return columns from joined tables:
+```typescript
+const updatedUsers = await db
+  .update(users)
+  .set({ cityId: cities.id })
+  .from(cities)
+  .returning({ id: users.id, cityName: cities.name });
+```

package/lovely-docs/drizzle-orm/upgrade-to-0.21.0.md

@@ -0,0 +1,40 @@
+## Breaking Changes
+
+**Dialect prefix removal**: Remove `:dialect` from drizzle-kit commands. Change `drizzle-kit push:mysql` to `drizzle-kit push`.
+
+**drizzle.config.ts updates**:
+- `dialect` is now mandatory: `"postgresql"`, `"mysql"`, or `"sqlite"`
+- `driver` is optional, only use if: `aws-data-api`, `turso`, `d1-http` (WIP), or `expo`
+- Replace `connectionString` or `uri` with `url` in `dbCredentials`
+- New `migrations` object for custom table/schema:
+  ```ts
+  import { defineConfig } from "drizzle-kit"
+  export default defineConfig({
+    dialect: "sqlite",
+    driver: "turso",
+    dbCredentials: { url: "" },
+    migrations: { table: "migrations", schema: "public" }
+  })
+  ```
+
+**Snapshot upgrade**: PostgreSQL and SQLite snapshots upgrade to version 6. Run `drizzle-kit up` to upgrade.
+
+**Driver auto-selection** (when no driver specified):
+- PostgreSQL: tries `pg` → `postgres` → `@vercel/postgres` → `@neondatabase/serverless`
+- MySQL: tries `mysql2` → `@planetscale/database`
+- SQLite: tries `@libsql/client` → `better-sqlite3`
+
+**MySQL schemas removed**: Drizzle Kit no longer handles schema changes for additional schemas/databases.
+
+## New Features
+
+**Pull relations**: Drizzle extracts foreign key information and generates `relations.ts` during introspection.
+
+**Custom migration names**: Use `drizzle-kit generate --name init_db`
+
+**New migrate command**: `drizzle-kit migrate` applies generated migrations directly. By default stores in `__drizzle_migrations` table (PostgreSQL: `drizzle` schema). Customize via `drizzle.config.ts`:
+```ts
+export default defineConfig({
+  migrations: { table: "migrations", schema: "public" }
+})
+```

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

@@ -0,0 +1,115 @@
+## Overview
+`drizzle-valibot` is a plugin for Drizzle ORM that generates Valibot schemas from Drizzle ORM table definitions. Requires `drizzle-valibot@0.3.0+`, Drizzle ORM v0.36.0+, and Valibot v1.0.0-beta.7+.
+
+## Select Schema
+Validates data queried from the database (useful for API responses).
+
+```ts
+import { pgTable, text, integer } from 'drizzle-orm/pg-core';
+import { createSelectSchema } from 'drizzle-valibot';
+import { parse } from 'valibot';
+
+const users = pgTable('users', {
+  id: integer().generatedAlwaysAsIdentity().primaryKey(),
+  name: text().notNull(),
+  age: integer().notNull()
+});
+
+const userSelectSchema = createSelectSchema(users);
+const rows = await db.select().from(users).limit(1);
+const parsed = parse(userSelectSchema, rows[0]); // { id: number; name: string; age: number }
+```
+
+Works with views and enums:
+```ts
+const roles = pgEnum('roles', ['admin', 'basic']);
+const rolesSchema = createSelectSchema(roles);
+const parsed = parse(rolesSchema, ...); // 'admin' | 'basic'
+
+const usersView = pgView('users_view').as((qb) => qb.select().from(users).where(gt(users.age, 18)));
+const usersViewSchema = createSelectSchema(usersView);
+```
+
+## Insert Schema
+Validates data before inserting into the database (useful for API requests). Auto-generated columns are excluded.
+
+```ts
+const userInsertSchema = createInsertSchema(users);
+const user = { name: 'Jane', age: 30 };
+const parsed = parse(userInsertSchema, user); // { name: string, age: number }
+await db.insert(users).values(parsed);
+```
+
+## Update Schema
+Validates data before updating in the database. All fields become optional, and generated columns cannot be updated.
+
+```ts
+const userUpdateSchema = createUpdateSchema(users);
+const user = { age: 35 };
+const parsed = parse(userUpdateSchema, user); // { name?: string | undefined, age?: number | undefined }
+await db.update(users).set(parsed).where(eq(users.name, 'Jane'));
+```
+
+## Refinements
+All `createSelectSchema`, `createInsertSchema`, and `createUpdateSchema` functions accept an optional second parameter to extend, modify, or overwrite field schemas. Pass a callback function to extend/modify, or a Valibot schema to overwrite.
+
+```ts
+const userSelectSchema = createSelectSchema(users, {
+  name: (schema) => pipe(schema, maxLength(20)), // Extends schema
+  bio: (schema) => pipe(schema, maxLength(1000)), // Extends before nullability
+  preferences: object({ theme: string() }) // Overwrites field including nullability
+});
+```
+
+## Data Type Reference
+Maps Drizzle ORM column types to Valibot schemas:
+
+**Boolean**: `pg.boolean()` → `boolean()`
+
+**Date**: `pg.date({ mode: 'date' })`, `pg.timestamp({ mode: 'date' })` → `date()`
+
+**String**: `pg.text()`, `pg.varchar()`, `mysql.binary()`, etc. → `string()`
+
+**Bit**: `pg.bit({ dimensions: ... })` → `pipe(string(), regex(/^[01]+$/), maxLength(dimensions))`
+
+**UUID**: `pg.uuid()` → `pipe(string(), uuid())`
+
+**Char**: `pg.char({ length: ... })` → `pipe(string(), length(length))`
+
+**Varchar**: `pg.varchar({ length: ... })` → `pipe(string(), maxLength(length))`
+
+**MySQL text variants**: `mysql.tinytext()` → `pipe(string(), maxLength(255))`, `mysql.text()` → `maxLength(65_535)`, `mysql.mediumtext()` → `maxLength(16_777_215)`, `mysql.longtext()` → `maxLength(4_294_967_295)`
+
+**Enum**: `pg.text({ enum: [...] })` → `enum([...])`
+
+**Integer types with range validation**:
+- `mysql.tinyint()` → `pipe(number(), minValue(-128), maxValue(127), integer())`
+- `mysql.tinyint({ unsigned: true })` → `pipe(number(), minValue(0), maxValue(255), integer())`
+- `pg.smallint()` → `pipe(number(), minValue(-32_768), maxValue(32_767), integer())`
+- `mysql.smallint({ unsigned: true })` → `pipe(number(), minValue(0), maxValue(65_535), integer())`
+- `pg.real()`, `mysql.float()` → `pipe(number(), minValue(-8_388_608), maxValue(8_388_607))`
+- `mysql.mediumint()` → `pipe(number(), minValue(-8_388_608), maxValue(8_388_607), integer())`
+- `mysql.float({ unsigned: true })` → `pipe(number(), minValue(0), maxValue(16_777_215))`
+- `mysql.mediumint({ unsigned: true })` → `pipe(number(), minValue(0), maxValue(16_777_215), integer())`
+- `pg.integer()`, `mysql.int()` → `pipe(number(), minValue(-2_147_483_648), maxValue(2_147_483_647), integer())`
+- `mysql.int({ unsigned: true })` → `pipe(number(), minValue(0), maxValue(4_294_967_295), integer())`
+- `pg.doublePrecision()`, `mysql.double()` → `pipe(number(), minValue(-140_737_488_355_328), maxValue(140_737_488_355_327))`
+- `mysql.double({ unsigned: true })` → `pipe(number(), minValue(0), maxValue(281_474_976_710_655))`
+- `pg.bigint({ mode: 'number' })` → `pipe(number(), minValue(-9_007_199_254_740_991), maxValue(9_007_199_254_740_991), integer())`
+- `mysql.serial()` → `pipe(number(), minValue(0), maxValue(9_007_199_254_740_991), integer())`
+- `pg.bigint({ mode: 'bigint' })` → `pipe(bigint(), minValue(-9_223_372_036_854_775_808n), maxValue(9_223_372_036_854_775_807n))`
+- `mysql.bigint({ mode: 'bigint', unsigned: true })` → `pipe(bigint(), minValue(0n), maxValue(18_446_744_073_709_551_615n))`
+
+**Year**: `mysql.year()` → `pipe(number(), minValue(1_901), maxValue(2_155), integer())`
+
+**Geometry**: `pg.point({ mode: 'tuple' })` → `tuple([number(), number()])`, `pg.point({ mode: 'xy' })` → `object({ x: number(), y: number() })`
+
+**Vectors**: `pg.vector({ dimensions: ... })` → `pipe(array(number()), length(dimensions))`
+
+**Line**: `pg.line({ mode: 'abc' })` → `object({ a: number(), b: number(), c: number() })`, `pg.line({ mode: 'tuple' })` → `tuple([number(), number(), number()])`
+
+**JSON**: `pg.json()`, `pg.jsonb()`, `mysql.json()` → `union([union([string(), number(), boolean(), null_()]), array(any()), record(string(), any())])`
+
+**Buffer**: `sqlite.blob({ mode: 'buffer' })` → `custom<Buffer>((v) => v instanceof Buffer)`
+
+**Arrays**: `pg.dataType().array(...)` → `pipe(array(baseDataTypeSchema), length(size))`

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

@@ -0,0 +1,135 @@
+## Declaring Views
+
+Views can be declared in three ways:
+1. **Inline query builder** - passed directly to `.as()`
+2. **Standalone query builder** - created separately and passed to `.as()`
+3. **Raw SQL** - using `sql` operator with explicit column schema
+
+### Basic Declaration (Inline Query Builder)
+
+PostgreSQL:
+```ts
+import { pgTable, pgView, serial, text, timestamp } from "drizzle-orm/pg-core";
+
+export const user = pgTable("user", {
+  id: serial(),
+  name: text(),
+  email: text(),
+  password: text(),
+  role: text().$type<"admin" | "customer">(),
+  createdAt: timestamp("created_at"),
+  updatedAt: timestamp("updated_at"),
+});
+
+export const userView = pgView("user_view").as((qb) => qb.select().from(user));
+export const customersView = pgView("customers_view").as((qb) => 
+  qb.select().from(user).where(eq(user.role, "customer"))
+);
+```
+
+MySQL and SQLite use `mysqlView` and `sqliteView` respectively with identical syntax.
+
+### Selecting Specific Columns
+
+```ts
+export const customersView = pgView("customers_view").as((qb) => {
+  return qb
+    .select({
+      id: user.id,
+      name: user.name,
+      email: user.email,
+    })
+    .from(user);
+});
+```
+
+### Standalone Query Builder
+
+```ts
+import { pgTable, pgView, serial, text, timestamp, QueryBuilder } from "drizzle-orm/pg-core";
+
+const qb = new QueryBuilder();
+
+export const userView = pgView("user_view").as(qb.select().from(user));
+export const customersView = pgView("customers_view").as(
+  qb.select().from(user).where(eq(user.role, "customer"))
+);
+```
+
+### Raw SQL Declaration
+
+When query builder syntax is insufficient, use `sql` operator with explicit column schema:
+
+```ts
+const newYorkers = pgView('new_yorkers', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  cityId: integer('city_id').notNull(),
+}).as(sql`select * from ${users} where ${eq(users.cityId, 1)}`);
+```
+
+## Existing Views
+
+For read-only access to existing database views, use `.existing()` to prevent migration generation:
+
+```ts
+export const trimmedUser = pgView("trimmed_user", {
+  id: serial("id"),
+  name: text("name"),
+  email: text("email"),
+}).existing();
+```
+
+## Materialized Views (PostgreSQL Only)
+
+PostgreSQL supports materialized views that persist results in table-like form.
+
+```ts
+const newYorkers = pgMaterializedView('new_yorkers').as((qb) => 
+  qb.select().from(users).where(eq(users.cityId, 1))
+);
+```
+
+Refresh at runtime:
+```ts
+await db.refreshMaterializedView(newYorkers);
+await db.refreshMaterializedView(newYorkers).concurrently();
+await db.refreshMaterializedView(newYorkers).withNoData();
+```
+
+## Extended Configuration
+
+Views support additional options via `.with()`, `.using()`, `.tablespace()`, and `.withNoData()`:
+
+```ts
+const newYorkers = pgView('new_yorkers')
+  .with({
+    checkOption: 'cascaded',
+    securityBarrier: true,
+    securityInvoker: true,
+  })
+  .as((qb) => {
+    const sq = qb
+      .$with('sq')
+      .as(
+        qb.select({ userId: users.id, cityId: cities.id })
+          .from(users)
+          .leftJoin(cities, eq(cities.id, users.homeCity))
+          .where(sql`${users.age1} > 18`),
+      );
+    return qb.with(sq).select().from(sq).where(sql`${users.homeCity} = 1`);
+  });
+
+const newYorkers2 = pgMaterializedView('new_yorkers')
+  .using('btree')
+  .with({
+    fillfactor: 90,
+    toast_tuple_target: 0.5,
+    autovacuum_enabled: true,
+  })
+  .tablespace('custom_tablespace')
+  .withNoData()
+  .as((qb) => { /* ... */ });
+```
+
+**Supported databases**: PostgreSQL, SQLite, MySQL (not SingleStore)

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

@@ -0,0 +1,66 @@
+## Headless ORM Philosophy
+Drizzle is a headless TypeScript ORM - a library and collection of opt-in tools that lets you build projects with it, not around it. Unlike data frameworks (Django-like, Spring-like), Drizzle doesn't force your project structure.
+
+## SQL-Like Query API
+Drizzle embraces SQL at its core. If you know SQL, you know Drizzle - zero to minimal learning curve. It provides SQL schema declaration, SQL-like queries, automatic migrations, and a relational query API.
+
+Example - SQL-like queries:
+```typescript
+await db
+  .select()
+  .from(countries)
+  .leftJoin(cities, eq(cities.countryId, countries.id))
+  .where(eq(countries.id, 10))
+```
+
+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),
+});
+```
+
+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") ON DELETE no action ON UPDATE no action;
+```
+
+## Relational Query API
+For common scenarios where SQL-like queries aren't optimal, Drizzle provides a Queries API for fetching nested relational data conveniently and performantly. Always outputs exactly 1 SQL query, making it serverless-database friendly.
+
+```typescript
+const result = await db.query.users.findMany({
+  with: {
+    posts: true
+  },
+});
+```
+
+## Serverless-Ready Design
+Drizzle has zero dependencies. It's dialect-specific, slim, performant, and serverless-ready by design. Supports PostgreSQL, MySQL, and SQLite through industry-standard database drivers.
+
+## Key Characteristics
+- Lightweight, performant, typesafe
+- Non-intrusive to project structure
+- Both SQL-like and relational query APIs
+- Zero dependencies
+- Serverless-ready
+- Full SQL dialect support

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

@@ -0,0 +1,113 @@
+## Overview
+`drizzle-zod` is a plugin that generates Zod schemas from Drizzle ORM schemas for validation.
+
+**Requirements:** drizzle-zod@0.6.0+, Drizzle ORM v0.36.0+, Zod v3.25.1+
+
+## Select Schema
+Validates data queried from the database (API responses).
+
+```ts
+import { pgTable, text, integer } from 'drizzle-orm/pg-core';
+import { createSelectSchema } from 'drizzle-zod';
+
+const users = pgTable('users', {
+  id: integer().generatedAlwaysAsIdentity().primaryKey(),
+  name: text().notNull(),
+  age: integer().notNull()
+});
+
+const userSelectSchema = createSelectSchema(users);
+const rows = await db.select().from(users).limit(1);
+const parsed = userSelectSchema.parse(rows[0]); // { id: number; name: string; age: number }
+```
+
+Supports views and enums:
+```ts
+const roles = pgEnum('roles', ['admin', 'basic']);
+const rolesSchema = createSelectSchema(roles);
+
+const usersView = pgView('users_view').as((qb) => qb.select().from(users).where(gt(users.age, 18)));
+const usersViewSchema = createSelectSchema(usersView);
+```
+
+## Insert Schema
+Validates data to be inserted (API requests).
+
+```ts
+import { createInsertSchema } from 'drizzle-zod';
+
+const userInsertSchema = createInsertSchema(users);
+const user = { name: 'Jane', age: 30 };
+const parsed = userInsertSchema.parse(user); // { name: string, age: number }
+await db.insert(users).values(parsed);
+```
+
+## Update Schema
+Validates data to be updated. Generated columns cannot be updated.
+
+```ts
+import { createUpdateSchema } from 'drizzle-zod';
+
+const userUpdateSchema = createUpdateSchema(users);
+const user = { age: 35 };
+const parsed = userUpdateSchema.parse(user); // { name?: string | undefined, age?: number | undefined }
+await db.update(users).set(parsed).where(eq(users.name, 'Jane'));
+```
+
+## Refinements
+Extend, modify, or overwrite field schemas via optional parameter:
+
+```ts
+const userSelectSchema = createSelectSchema(users, {
+  name: (schema) => schema.max(20), // Extends schema
+  bio: (schema) => schema.max(1000), // Extends before nullability
+  preferences: z.object({ theme: z.string() }) // Overwrites field
+});
+```
+
+## Factory Functions
+`createSchemaFactory` for advanced use cases.
+
+**Extended Zod instance:**
+```ts
+import { createSchemaFactory } from 'drizzle-zod';
+import { z } from '@hono/zod-openapi';
+
+const { createInsertSchema } = createSchemaFactory({ zodInstance: z });
+const userInsertSchema = createInsertSchema(users, {
+  name: (schema) => schema.openapi({ example: 'John' })
+});
+```
+
+**Type coercion:**
+```ts
+const { createInsertSchema } = createSchemaFactory({
+  coerce: { date: true } // or coerce: true for all types
+});
+const userInsertSchema = createInsertSchema(users);
+// createdAt: z.coerce.date()
+```
+
+## Data Type Reference
+Comprehensive mapping of Drizzle column types to Zod schemas:
+
+- **Boolean:** `pg.boolean()` → `z.boolean()`
+- **Date:** `pg.date({ mode: 'date' })`, `pg.timestamp({ mode: 'date' })` → `z.date()`
+- **String:** `pg.text()`, `pg.varchar()`, `mysql.binary()` → `z.string()`
+- **UUID:** `pg.uuid()` → `z.string().uuid()`
+- **Char:** `pg.char({ length: 10 })` → `z.string().length(10)`
+- **Varchar:** `pg.varchar({ length: 100 })` → `z.string().max(100)`
+- **MySQL text variants:** `tinytext` → `z.string().max(255)`, `text` → `z.string().max(65_535)`, `mediumtext` → `z.string().max(16_777_215)`, `longtext` → `z.string().max(4_294_967_295)`
+- **Enum:** `pg.text({ enum: ['a', 'b'] })` → `z.enum(['a', 'b'])`
+- **Bit:** `pg.bit({ dimensions: 8 })` → `z.string().regex(/^[01]+$/).max(8)`
+- **Integer types:** `pg.smallint()` → `z.number().min(-32_768).max(32_767).int()`, `pg.integer()` → `z.number().min(-2_147_483_648).max(2_147_483_647).int()`, `mysql.tinyint()` → `z.number().min(-128).max(127).int()`, unsigned variants adjust min to 0
+- **Float/Double:** `pg.real()`, `mysql.float()` → `z.number()` with appropriate bit limits
+- **BigInt:** `pg.bigint({ mode: 'bigint' })` → `z.bigint().min(-9_223_372_036_854_775_808n).max(9_223_372_036_854_775_807n)`, unsigned → `z.bigint().min(0).max(18_446_744_073_709_551_615n)`
+- **BigInt (number mode):** `pg.bigint({ mode: 'number' })` → `z.number().min(-9_007_199_254_740_991).max(9_007_199_254_740_991).int()`
+- **Year:** `mysql.year()` → `z.number().min(1_901).max(2_155).int()`
+- **Geometry:** `pg.point({ mode: 'tuple' })` → `z.tuple([z.number(), z.number()])`, `pg.point({ mode: 'xy' })` → `z.object({ x: z.number(), y: z.number() })`
+- **Vector:** `pg.vector({ dimensions: 3 })` → `z.array(z.number()).length(3)`
+- **Line:** `pg.line({ mode: 'abc' })` → `z.object({ a: z.number(), b: z.number(), c: z.number() })`, `pg.line({ mode: 'tuple' })` → `z.tuple([z.number(), z.number(), z.number()])`
+- **JSON:** `pg.json()`, `pg.jsonb()` → `z.union([z.union([z.string(), z.number(), z.boolean(), z.null()]), z.record(z.any()), z.array(z.any())])`
+- **Buffer:** `sqlite.blob({ mode: 'buffer' })` → `z.custom<Buffer>((v) => v instanceof Buffer)`
+- **Array:** `pg.dataType().array(size)` → `z.array(baseDataTypeSchema).length(size)`

package/lovely-docs/drizzle-orm.md

@@ -0,0 +1,60 @@
+This is the complete Drizzle ORM documentation covering all aspects of the library. It includes:
+
+**Core Concepts**: Drizzle is a headless TypeScript ORM with SQL-like and relational query APIs, zero dependencies, and serverless-ready design. It supports PostgreSQL, MySQL, SQLite, and SingleStore.
+
+**Schema Definition**: Define tables using dialect-specific functions (pgTable, mysqlTable, sqliteTable) with typed columns. Supports constraints (NOT NULL, UNIQUE, PRIMARY KEY, FOREIGN KEY, CHECK, DEFAULT), indexes, and relations. PostgreSQL supports schemas via pgSchema, MySQL schemas are databases, SQLite has no schemas.
+
+**Column Types**: Comprehensive type system across all databases including numeric (int, serial, bigint, decimal, real), string (text, varchar, char), boolean, date/time (date, timestamp, time), JSON, arrays (PostgreSQL), and specialized types (UUID, point, geometry, vector, enum). Supports type inference with `.$type<T>()` and runtime defaults via `.$defaultFn()` and `.$onUpdate()`.
+
+**Query APIs**: Two approaches - SQL-like syntax mirroring SQL (select/insert/update/delete with joins, filters, aggregations) and Relational Queries API for nested data fetching. Both are type-safe and generate exactly one SQL statement.
+
+**Filtering & Operators**: Comparison (eq, ne, gt, gte, lt, lte), existence (exists, notExists), null checks (isNull, isNotNull), arrays (inArray, notInArray), ranges (between, notBetween), patterns (like, ilike), logical (not, and, or), and PostgreSQL-specific array operators (arrayContains, arrayContained, arrayOverlaps).
+
+**Advanced Queries**: CTEs (WITH clauses), subqueries, aggregations (count, sum, avg, max, min with distinct variants), pagination (limit/offset and cursor-based), joins (left/right/inner/full/cross with lateral variants), set operations (UNION, INTERSECT, EXCEPT with ALL variants), and full-text search (PostgreSQL with tsvector/tsquery, weighted multi-column search, ranking).
+
+**Mutations**: Insert (single/multiple rows, returning, $returningId for MySQL/SingleStore, onConflict/onDuplicate for upserts), update (with set, where, limit, orderBy, returning, FROM joins), delete (with where, limit, orderBy, returning). All support WITH clauses.
+
+**Relationships**: Define one-to-one, one-to-many, and many-to-many relations using one() and many() operators. Relations are application-level abstractions independent from database foreign keys. Foreign key actions (CASCADE, RESTRICT, NO ACTION, SET NULL, SET DEFAULT) control delete/update behavior.
+
+**Database Setup**: Comprehensive guides for 30+ platforms including PostgreSQL (node-postgres, postgres.js), MySQL (mysql2), SQLite (libsql, better-sqlite3, bun:sqlite, expo-sqlite, op-sqlite), serverless options (Neon, Supabase, Vercel Postgres, PlanetScale, Turso, Cloudflare D1), edge functions (Netlify, Supabase, Vercel), and specialized platforms (Xata, Nile, TiDB, PGLite, Prisma Postgres).
+
+**Drizzle Kit**: CLI tool for migrations with commands: generate (create SQL from schema changes), migrate (apply migrations), push (sync schema directly), pull (introspect existing database), studio (local database browser), check (validate migration history), up (upgrade snapshots), export (output DDL). Configured via drizzle.config.ts with dialect, schema paths, database credentials, and optional filters.
+
+**Migrations**: Six strategies - database-first (pull), codebase-first with direct push, SQL file generation with CLI/runtime application, manual application, or export for external tools. Supports custom migration names, empty migrations for manual SQL, and custom migrations table/schema configuration.
+
+**Advanced Features**: 
+- Prepared statements for performance with placeholders
+- Transactions with nested savepoints, rollback conditions, and dialect-specific isolation levels
+- Read replicas with automatic routing via withReplicas()
+- Row-Level Security (PostgreSQL) with policies, roles, and provider support (Neon, Supabase)
+- Batch API for LibSQL, Neon, D1 (multiple statements in single call)
+- Query caching with Upstash Redis or custom implementation
+- Dynamic query building with .$dynamic() for reusable functions
+- Sequences (PostgreSQL) for auto-incrementing IDs
+- Generated columns (PostgreSQL STORED, MySQL/SQLite STORED/VIRTUAL)
+- Views (inline/standalone/raw SQL, materialized views for PostgreSQL)
+- Custom types via customType() with toDriver/fromDriver mapping
+- HTTP proxy driver for custom database communication
+- Logging configuration with DefaultLogger or custom Logger
+- Multi-project schema namespacing with pgTableCreator
+- Type helpers (InferSelectModel, InferInsertModel, getTableColumns, getTableConfig)
+- Mock driver for testing
+
+**Validation Plugins**: Generate validation schemas from Drizzle tables:
+- Zod (createSelectSchema, createInsertSchema, createUpdateSchema with refinements)
+- Valibot (same API as Zod)
+- Typebox (same API)
+- Arktype (same API)
+- All support field refinements and comprehensive type mappings
+
+**Patterns & Recipes**: Conditional filtering, counting rows, column selection, parent-child queries, pagination (limit/offset and cursor-based), incrementing/decrementing, toggling booleans, bulk updates with CASE, upserts, full-text search, vector similarity search, geospatial queries (point distance, rectangular boundaries, PostGIS), timestamp defaults, empty array defaults, case-insensitive unique emails, seeding with related entities.
+
+**Seeding**: drizzle-seed for deterministic fake data generation with seedable pRNG. 30+ generators (numeric, string, person, location, business, geometric) with options for uniqueness, ranges, arrays. Supports weighted distributions, related entity creation, and versioning for reproducible outputs.
+
+**Ecosystem**: GraphQL schema generation (drizzle-graphql), Prisma extension for native Drizzle integration, ESLint plugin with enforce-delete-with-where and enforce-update-with-where rules.
+
+**Migration Guides**: Step-by-step guides from Prisma, Sequelize, and TypeORM to Drizzle with query pattern replacements.
+
+**Getting Started**: Quick start with PostgreSQL, edge function integration (Netlify, Supabase, Vercel), database provider guides (Neon, Supabase, Turso, Vercel Postgres, Xata, Nile), and complete Next.js todo app tutorial.
+
+**Release Notes**: Evolution from v0.11.0 through v0.32.2 documenting feature additions including schema constraints, query building, drivers, timestamp handling, advanced features (pg_vector, PostGIS, prepared statements, batch API, caching, dynamic queries, sequences, generated columns).

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@lunarhue/expo-wa-sqlite",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@lunarhue/wa-sqlite": "1.0.14"
+  },
+  "peerDependencies": {
+    "drizzle-orm": "*",
+    "expo": "*",
+    "react": "*"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}