@lunarhue/expo-wa-sqlite 0.0.1

package/lovely-docs/drizzle-orm/indexes-constraints.md

@@ -0,0 +1,135 @@
+## Constraints
+
+**DEFAULT**: Specifies default value for a column if no value provided on INSERT. Can be a constant, expression, or NULL.
+```typescript
+integer('col').default(42)
+integer('col').default(sql`'42'::integer`)
+uuid('col').defaultRandom()
+```
+
+**NOT NULL**: Enforces column to not accept NULL values.
+```typescript
+integer('col').notNull()
+```
+
+**UNIQUE**: Ensures all values in column are different. Can be single or composite (multiple columns). Supports custom names and NULLS NOT DISTINCT (PostgreSQL 15+).
+```typescript
+integer('id').unique()
+integer('id').unique('custom_name')
+// Composite
+pgTable('table', { id: integer('id'), name: text('name') }, (t) => [
+  unique().on(t.id, t.name),
+  unique('custom_name').on(t.id, t.name),
+  unique().on(t.id).nullsNotDistinct() // PG 15+
+])
+```
+
+**CHECK**: Limits value range for a column or based on multiple columns.
+```typescript
+pgTable('users', {
+  id: uuid().defaultRandom().primaryKey(),
+  username: text().notNull(),
+  age: integer(),
+}, (table) => [
+  check('age_check1', sql`${table.age} > 21`)
+])
+```
+
+**PRIMARY KEY**: Uniquely identifies each record. Must be UNIQUE and NOT NULL. Only one per table, can be single or composite column.
+```typescript
+serial('id').primaryKey()
+text('cuid').primaryKey()
+// Composite
+pgTable('books_to_authors', {
+  authorId: integer('author_id'),
+  bookId: integer('book_id'),
+}, (table) => [
+  primaryKey({ columns: [table.bookId, table.authorId] }),
+  primaryKey({ name: 'custom_name', columns: [table.bookId, table.authorId] })
+])
+```
+
+**FOREIGN KEY**: References PRIMARY KEY in another table. Prevents actions that destroy links between tables. Can be declared inline or standalone.
+```typescript
+// Inline
+integer('author_id').references(() => user.id)
+
+// Self-reference (requires explicit return type)
+integer('parent_id').references((): AnyPgColumn => user.id)
+
+// Standalone
+pgTable('user', {
+  id: serial('id'),
+  name: text('name'),
+  parentId: integer('parent_id'),
+}, (table) => [
+  foreignKey({
+    columns: [table.parentId],
+    foreignColumns: [table.id],
+    name: 'custom_fk'
+  })
+])
+
+// Multicolumn
+pgTable('profile', {
+  id: serial('id'),
+  userFirstName: text('user_first_name'),
+  userLastName: text('user_last_name'),
+}, (table) => [
+  foreignKey({
+    columns: [table.userFirstName, table.userLastName],
+    foreignColumns: [user.firstName, user.lastName],
+    name: 'custom_fk'
+  })
+])
+```
+
+## Indexes
+
+Drizzle ORM supports `index()` and `uniqueIndex()` declarations.
+
+**Basic usage**:
+```typescript
+pgTable('user', {
+  id: serial('id').primaryKey(),
+  name: text('name'),
+  email: text('email'),
+}, (table) => [
+  index('name_idx').on(table.name),
+  uniqueIndex('email_idx').on(table.email)
+])
+```
+
+**PostgreSQL (0.31.0+)** supports advanced index API:
+```typescript
+// With .on()
+index('name')
+  .on(table.column1.asc(), table.column2.nullsFirst())
+  .concurrently()
+  .where(sql`condition`)
+  .with({ fillfactor: '70' })
+
+// With .using()
+index('name')
+  .using('btree', table.column1.asc(), sql`lower(${table.column2})`)
+  .where(sql`condition`)
+  .with({ fillfactor: '70' })
+```
+
+**MySQL** supports:
+```typescript
+index('name')
+  .on(table.name)
+  .algorythm('default' | 'copy' | 'inplace')
+  .using('btree' | 'hash')
+  .lock('none' | 'default' | 'exclusive' | 'shared')
+```
+
+**SQLite** supports:
+```typescript
+index('name')
+  .on(table.name)
+  .where(sql`condition`)
+```
+
+Supported across PostgreSQL, MySQL, SQLite, and SingleStore (with varying feature support).

package/lovely-docs/drizzle-orm/insert.mdx.md

@@ -0,0 +1,118 @@
+## Insert one row
+```typescript
+await db.insert(users).values({ name: 'Andrew' });
+```
+Type inference: `type NewUser = typeof users.$inferInsert;`
+
+## Insert returning
+Supported in PostgreSQL and SQLite:
+```typescript
+await db.insert(users).values({ name: "Dan" }).returning();
+await db.insert(users).values({ name: "Partial Dan" }).returning({ insertedId: users.id });
+```
+
+## Insert $returningId
+MySQL and SingleStore alternative (no native RETURNING support). Returns inserted IDs for autoincrement primary keys:
+```typescript
+const result = await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]).$returningId();
+// ^? { id: number }[]
+```
+Also works with custom primary keys using `$defaultFn`:
+```typescript
+const usersTableDefFn = mysqlTable('users_default_fn', {
+  customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(createId),
+  name: text('name').notNull(),
+});
+const result = await db.insert(usersTableDefFn).values([{ name: 'John' }, { name: 'John1' }]).$returningId();
+// ^? { customId: string }[]
+```
+If no primary keys exist, type is `{}[]`.
+
+## Insert multiple rows
+```typescript
+await db.insert(users).values([{ name: 'Andrew' }, { name: 'Dan' }]);
+```
+
+## On conflict do nothing
+PostgreSQL and SQLite:
+```typescript
+await db.insert(users).values({ id: 1, name: 'John' }).onConflictDoNothing();
+await db.insert(users).values({ id: 1, name: 'John' }).onConflictDoNothing({ target: users.id });
+```
+
+## On conflict do update
+PostgreSQL and SQLite:
+```typescript
+await db.insert(users).values({ id: 1, name: 'Dan' }).onConflictDoUpdate({ target: users.id, set: { name: 'John' } });
+```
+
+With `where` clauses using `targetWhere` (partial indexes) and `setWhere` (update conditions):
+```typescript
+await db.insert(employees).values({ employeeId: 123, name: 'John Doe' }).onConflictDoUpdate({
+  target: employees.employeeId,
+  targetWhere: sql`name <> 'John Doe'`,
+  set: { name: sql`excluded.name` }
+});
+
+await db.insert(employees).values({ employeeId: 123, name: 'John Doe' }).onConflictDoUpdate({
+  target: employees.employeeId,
+  set: { name: 'John Doe' },
+  setWhere: sql`name <> 'John Doe'`
+});
+```
+
+Composite indexes/primary keys:
+```typescript
+await db.insert(users).values({ firstName: 'John', lastName: 'Doe' }).onConflictDoUpdate({
+  target: [users.firstName, users.lastName],
+  set: { firstName: 'John1' }
+});
+```
+
+## On duplicate key update
+MySQL and SingleStore (automatically determines conflict target from primary key and unique indexes):
+```typescript
+await db.insert(users).values({ id: 1, name: 'John' }).onDuplicateKeyUpdate({ set: { name: 'John' } });
+```
+
+No-op on conflict by setting a column to itself:
+```typescript
+await db.insert(users).values({ id: 1, name: 'John' }).onDuplicateKeyUpdate({ set: { id: sql`id` } });
+```
+
+## WITH clause
+```typescript
+const userCount = db.$with('user_count').as(
+  db.select({ value: sql`count(*)`.as('value') }).from(users)
+);
+
+const result = await db.with(userCount).insert(users).values([
+  { username: 'user1', admin: sql`((select * from ${userCount}) = 0)` }
+]).returning({ admin: users.admin });
+```
+
+## Insert into ... select
+Three approaches:
+
+Query builder:
+```typescript
+const insertedEmployees = await db.insert(employees).select(
+  db.select({ name: users.name }).from(users).where(eq(users.role, 'employee'))
+).returning({ id: employees.id, name: employees.name });
+```
+
+Callback:
+```typescript
+await db.insert(employees).select(
+  () => db.select({ name: users.name }).from(users).where(eq(users.role, 'employee'))
+);
+```
+
+SQL template tag:
+```typescript
+await db.insert(employees).select(
+  sql`select "users"."name" as "name" from "users" where "users"."role" = 'employee'`
+);
+```
+
+Note: For upsert clauses, SELECT must include WHERE clause (even `WHERE true`) to avoid parsing ambiguity.

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

@@ -0,0 +1,145 @@
+## Join Types
+
+Drizzle ORM supports: `INNER JOIN [LATERAL]`, `FULL JOIN`, `LEFT JOIN [LATERAL]`, `RIGHT JOIN`, `CROSS JOIN [LATERAL]`.
+
+### Left Join
+```typescript
+const result = await db.select().from(users).leftJoin(pets, eq(users.id, pets.ownerId))
+// Result: { user: {...}, pets: {...} | null }[]
+```
+
+### Left Join Lateral
+```typescript
+const subquery = db.select().from(pets).where(gte(users.age, 16)).as('userPets')
+const result = await db.select().from(users).leftJoinLateral(subquery, sql`true`)
+// Result: { user: {...}, userPets: {...} | null }[]
+```
+
+### Right Join
+```typescript
+const result = await db.select().from(users).rightJoin(pets, eq(users.id, pets.ownerId))
+// Result: { user: {...} | null, pets: {...} }[]
+```
+
+### Inner Join
+```typescript
+const result = await db.select().from(users).innerJoin(pets, eq(users.id, pets.ownerId))
+// Result: { user: {...}, pets: {...} }[]
+```
+
+### Inner Join Lateral
+```typescript
+const subquery = db.select().from(pets).where(gte(users.age, 16)).as('userPets')
+const result = await db.select().from(users).innerJoinLateral(subquery, sql`true`)
+// Result: { user: {...}, userPets: {...} }[]
+```
+
+### Full Join
+```typescript
+const result = await db.select().from(users).fullJoin(pets, eq(users.id, pets.ownerId))
+// Result: { user: {...} | null, pets: {...} | null }[]
+```
+
+### Cross Join
+```typescript
+const result = await db.select().from(users).crossJoin(pets)
+// Result: { user: {...}, pets: {...} }[]
+```
+
+### Cross Join Lateral
+```typescript
+const subquery = db.select().from(pets).where(gte(users.age, 16)).as('userPets')
+const result = await db.select().from(users).crossJoinLateral(subquery)
+// Result: { user: {...}, userPets: {...} }[]
+```
+
+## Partial Select
+
+Select specific fields to flatten response type:
+```typescript
+await db.select({
+  userId: users.id,
+  petId: pets.id,
+}).from(users).leftJoin(pets, eq(users.id, pets.ownerId))
+// Result: { userId: number, petId: number | null }[]
+```
+
+When using `sql` operator with joins, explicitly type nullable fields:
+```typescript
+const result = await db.select({
+  userId: users.id,
+  petId: pets.id,
+  petName1: sql`upper(${pets.name})`,
+  petName2: sql<string | null>`upper(${pets.name})`,
+}).from(users).leftJoin(pets, eq(users.id, pets.ownerId))
+// Result: { userId: number, petId: number | null, petName1: unknown, petName2: string | null }[]
+```
+
+Use nested select object syntax to make entire object nullable instead of individual fields:
+```typescript
+await db.select({
+  userId: users.id,
+  userName: users.name,
+  pet: {
+    id: pets.id,
+    name: pets.name,
+    upperName: sql<string>`upper(${pets.name})`
+  }
+}).from(users).fullJoin(pets, eq(users.id, pets.ownerId))
+// Result: { userId: number | null, userName: string | null, pet: {...} | null }[]
+```
+
+## Aliases & Self-joins
+
+Use `alias()` for self-joins:
+```typescript
+import { alias } from 'drizzle-orm';
+const parent = alias(user, "parent");
+const result = db.select().from(user).leftJoin(parent, eq(parent.id, user.parentId))
+// Result: { user: {...}, parent: {...} | null }[]
+```
+
+## Aggregating Results
+
+Map join results to aggregate related data:
+```typescript
+type User = typeof users.$inferSelect;
+type Pet = typeof pets.$inferSelect;
+
+const rows = db.select({ user: users, pet: pets })
+  .from(users).leftJoin(pets, eq(users.id, pets.ownerId)).all();
+
+const result = rows.reduce<Record<number, { user: User; pets: Pet[] }>>(
+  (acc, row) => {
+    const user = row.user;
+    const pet = row.pet;
+    if (!acc[user.id]) acc[user.id] = { user, pets: [] };
+    if (pet) acc[user.id].pets.push(pet);
+    return acc;
+  },
+  {}
+);
+// Result: Record<number, { user: User; pets: Pet[] }>
+```
+
+## Many-to-One Example
+```typescript
+const cities = sqliteTable('cities', { id: integer('id').primaryKey(), name: text('name') });
+const users = sqliteTable('users', { id: integer('id').primaryKey(), name: text('name'), cityId: integer('city_id').references(() => cities.id) });
+
+const result = db.select().from(cities).leftJoin(users, eq(cities.id, users.cityId)).all();
+```
+
+## Many-to-Many Example
+```typescript
+const users = sqliteTable('users', { id: integer('id').primaryKey(), name: text('name') });
+const chatGroups = sqliteTable('chat_groups', { id: integer('id').primaryKey(), name: text('name') });
+const usersToChatGroups = sqliteTable('usersToChatGroups', { userId: integer('user_id').references(() => users.id), groupId: integer('group_id').references(() => chatGroups.id) });
+
+db.select()
+  .from(usersToChatGroups)
+  .leftJoin(users, eq(usersToChatGroups.userId, users.id))
+  .leftJoin(chatGroups, eq(usersToChatGroups.groupId, chatGroups.id))
+  .where(eq(chatGroups.id, 1))
+  .all();
+```

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

@@ -0,0 +1,81 @@
+## Drizzle Kit Overview
+
+Drizzle Kit is a CLI tool for managing SQL database migrations with Drizzle ORM.
+
+### Installation
+```
+npm install -D drizzle-kit
+```
+
+### Core Commands
+
+- **drizzle-kit generate** - Generate SQL migration files based on your Drizzle schema (initial or subsequent changes)
+- **drizzle-kit migrate** - Apply generated SQL migration files to your database
+- **drizzle-kit push** - Push your Drizzle schema directly to database (without generating migration files)
+- **drizzle-kit pull** - Introspect database schema, convert to Drizzle schema, save to codebase
+- **drizzle-kit studio** - Connect to database and spin up proxy server for Drizzle Studio for database browsing
+- **drizzle-kit check** - Walk through all generated migrations and check for race conditions/collisions
+- **drizzle-kit up** - Upgrade snapshots of previously generated migrations
+
+### Configuration
+
+Drizzle Kit is configured via `drizzle.config.ts` file. Minimum required: `dialect` and `schema` path.
+
+Simple config:
+```ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "postgresql",
+  schema: "./src/schema.ts",
+});
+```
+
+Extended config with all options:
+```ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  out: "./drizzle",
+  dialect: "postgresql",
+  schema: "./src/schema.ts",
+  driver: "pglite",
+  dbCredentials: {
+    url: "./database/",
+  },
+  extensionsFilters: ["postgis"],
+  schemaFilter: "public",
+  tablesFilter: "*",
+  introspect: {
+    casing: "camel",
+  },
+  migrations: {
+    prefix: "timestamp",
+    table: "__drizzle_migrations__",
+    schema: "public",
+  },
+  breakpoints: true,
+  strict: true,
+  verbose: true,
+});
+```
+
+### Multiple Configurations
+
+Provide config path via CLI for different database stages:
+```
+drizzle-kit push --config=drizzle-dev.config.ts
+drizzle-kit push --config=drizzle-prod.config.ts
+```
+
+Project structure example:
+```
+📦 <project root>
+ ├ 📂 drizzle
+ ├ 📂 src
+ ├ 📜 .env
+ ├ 📜 drizzle-dev.config.ts
+ ├ 📜 drizzle-prod.config.ts
+ ├ 📜 package.json
+ └ 📜 tsconfig.json
+```

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

@@ -0,0 +1,54 @@
+## Purpose
+`drizzle-kit migrate` applies SQL migrations generated by `drizzle-kit generate`. It implements the code-first approach to managing migrations.
+
+## How it works
+1. Reads all `.sql` migration files from the migrations folder
+2. Connects to database and fetches entries from the drizzle migrations log table (`__drizzle_migrations`)
+3. Determines which migrations haven't been applied yet
+4. Runs new SQL migrations and logs them to the migrations table
+
+## Configuration
+Requires `dialect` and database connection credentials via `drizzle.config.ts` or CLI options:
+
+```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"
+  },
+  migrations: {
+    table: '__drizzle_migrations', // customizable
+    schema: 'drizzle', // PostgreSQL only
+  },
+});
+```
+
+```shell
+npx drizzle-kit migrate
+# or with CLI options
+npx drizzle-kit migrate --dialect=postgresql --url=postgresql://user:password@host:port/dbname
+```
+
+## Multiple configurations
+Support multiple config files for different database stages:
+```shell
+npx drizzle-kit migrate --config=drizzle-dev.config.ts
+npx drizzle-kit migrate --config=drizzle-prod.config.ts
+```
+
+## Example workflow
+1. Define schema in `src/schema.ts`:
+```ts
+import * as p from "drizzle-orm/pg-core";
+export const users = p.pgTable("users", {
+  id: p.serial().primaryKey(),
+  name: p.text(),
+})
+```
+
+2. Generate migration: `npx drizzle-kit generate --name=init` creates `0000_init.sql`
+3. Apply migration: `npx drizzle-kit migrate` runs the SQL and logs it to database