@lunarhue/expo-wa-sqlite 0.0.1

package/lovely-docs/drizzle-orm/schema-declaration.md

@@ -0,0 +1,239 @@
+## Schema Organization
+
+Drizzle schemas can be organized in a single file or spread across multiple files. All models must be exported for Drizzle-Kit to use them in migrations.
+
+**Single file approach:**
+```
+src/db/schema.ts
+```
+Configure in `drizzle.config.ts`:
+```ts
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts'
+})
+```
+
+**Multiple files approach:**
+```
+src/db/schema/
+  ├ users.ts
+  ├ countries.ts
+  ├ products.ts
+```
+Configure in `drizzle.config.ts`:
+```ts
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema'
+})
+```
+
+## Tables and Columns
+
+Tables must be defined with at least 1 column using dialect-specific functions (pgTable, mysqlTable, sqliteTable).
+
+**PostgreSQL:**
+```ts
+import { pgTable, integer, varchar } from "drizzle-orm/pg-core";
+export const users = pgTable('users', {
+  id: integer(),
+  firstName: varchar('first_name')
+})
+```
+
+**MySQL:**
+```ts
+import { mysqlTable, int, varchar } from "drizzle-orm/mysql-core";
+export const users = mysqlTable('users', {
+  id: int(),
+  firstName: varchar('first_name', { length: 256 })
+})
+```
+
+**SQLite:**
+```ts
+import { sqliteTable, integer, text } from "drizzle-orm/sqlite-core";
+export const users = sqliteTable('users', {
+  id: integer(),
+  firstName: text('first_name')
+})
+```
+
+By default, TypeScript key names are used as database column names. Use column aliases (second parameter) to use different names.
+
+## Camel/Snake Case Mapping
+
+Use the `casing` option during database initialization to automatically map camelCase to snake_case:
+
+```ts
+const db = drizzle({ 
+  connection: process.env.DATABASE_URL, 
+  casing: 'snake_case' 
+})
+```
+
+With this, `firstName` in TypeScript automatically maps to `first_name` in the database.
+
+## Reusable Column Definitions
+
+Define common columns in a helper file and spread them across tables:
+
+```ts
+// columns.helpers.ts
+const timestamps = {
+  updated_at: timestamp(),
+  created_at: timestamp().defaultNow().notNull(),
+  deleted_at: timestamp(),
+}
+
+// users.ts
+export const users = pgTable('users', {
+  id: integer(),
+  ...timestamps
+})
+
+// posts.ts
+export const posts = pgTable('posts', {
+  id: integer(),
+  ...timestamps
+})
+```
+
+## PostgreSQL Schemas
+
+PostgreSQL supports schemas (namespace containers). Define with `pgSchema`:
+
+```ts
+import { pgSchema, integer } from "drizzle-orm/pg-core";
+
+export const customSchema = pgSchema('custom');
+
+export const users = customSchema.table('users', {
+  id: integer()
+})
+```
+
+## MySQL Schemas
+
+MySQL schemas are equivalent to databases. Can be defined but won't be detected by Drizzle-Kit or included in migrations:
+
+```ts
+import { mysqlSchema, int } from "drizzle-orm/mysql-core";
+
+export const customSchema = mysqlSchema('custom');
+
+export const users = customSchema.table('users', {
+  id: int()
+})
+```
+
+## SQLite
+
+SQLite has no schema concept; tables exist within a single file context.
+
+## Complete Example
+
+**PostgreSQL:**
+```ts
+import { pgEnum, pgTable as table, integer, varchar, uniqueIndex, index } from "drizzle-orm/pg-core";
+import { AnyPgColumn } from "drizzle-orm/pg-core";
+
+export const rolesEnum = pgEnum("roles", ["guest", "user", "admin"]);
+
+export const users = table("users", {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  firstName: varchar("first_name", { length: 256 }),
+  lastName: varchar("last_name", { length: 256 }),
+  email: varchar().notNull(),
+  invitee: integer().references((): AnyPgColumn => users.id),
+  role: rolesEnum().default("guest"),
+}, (table) => [
+  uniqueIndex("email_idx").on(table.email)
+]);
+
+export const posts = table("posts", {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  slug: varchar().$default(() => generateUniqueString(16)),
+  title: varchar({ length: 256 }),
+  ownerId: integer("owner_id").references(() => users.id),
+}, (table) => [
+  uniqueIndex("slug_idx").on(table.slug),
+  index("title_idx").on(table.title),
+]);
+
+export const comments = table("comments", {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  text: varchar({ length: 256 }),
+  postId: integer("post_id").references(() => posts.id),
+  ownerId: integer("owner_id").references(() => users.id),
+});
+```
+
+**MySQL:**
+```ts
+import { mysqlTable as table, int, varchar, mysqlEnum, uniqueIndex, index } from "drizzle-orm/mysql-core";
+import { AnyMySqlColumn } from "drizzle-orm/mysql-core";
+
+export const users = table("users", {
+  id: int().primaryKey().autoincrement(),
+  firstName: varchar("first_name", { length: 256 }),
+  lastName: varchar("last_name", { length: 256 }),
+  email: varchar({ length: 256 }).notNull(),
+  invitee: int().references((): AnyMySqlColumn => users.id),
+  role: mysqlEnum(["guest", "user", "admin"]).default("guest"),
+}, (table) => [
+  uniqueIndex("email_idx").on(table.email)
+]);
+
+export const posts = table("posts", {
+  id: int().primaryKey().autoincrement(),
+  slug: varchar({ length: 256 }).$default(() => generateUniqueString(16)),
+  title: varchar({ length: 256 }),
+  ownerId: int("owner_id").references(() => users.id),
+}, (table) => [
+  uniqueIndex("slug_idx").on(table.slug),
+  index("title_idx").on(table.title),
+]);
+
+export const comments = table("comments", {
+  id: int().primaryKey().autoincrement(),
+  text: varchar({ length: 256 }),
+  postId: int("post_id").references(() => posts.id),
+  ownerId: int("owner_id").references(() => users.id),
+});
+```
+
+**SQLite:**
+```ts
+import { sqliteTable as table, integer, text, uniqueIndex, index } from "drizzle-orm/sqlite-core";
+import { AnySQLiteColumn } from "drizzle-orm/sqlite-core";
+
+export const users = table("users", {
+  id: integer().primaryKey({ autoIncrement: true }),
+  firstName: text("first_name"),
+  lastName: text("last_name"),
+  email: text().notNull(),
+  invitee: integer().references((): AnySQLiteColumn => users.id),
+  role: text().$type<"guest" | "user" | "admin">().default("guest"),
+}, (table) => [
+  uniqueIndex("email_idx").on(table.email)
+]);
+
+export const posts = table("posts", {
+  id: integer().primaryKey({ autoIncrement: true }),
+  slug: text().$default(() => generateUniqueString(16)),
+  title: text(),
+  ownerId: integer("owner_id").references(() => users.id),
+}, (table) => [
+  uniqueIndex("slug_idx").on(table.slug),
+  index("title_idx").on(table.title),
+]);
+
+export const comments = table("comments", {
+  id: integer().primaryKey({ autoIncrement: true }),
+  text: text({ length: 256 }),
+  postId: integer("post_id").references(() => posts.id),
+  ownerId: integer("owner_id").references(() => users.id),
+});
+```

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

@@ -0,0 +1,63 @@
+## Table Schemas
+
+Drizzle ORM provides APIs for declaring SQL schemas in PostgreSQL, MySQL, and SingleStore dialects. When entities are declared within a schema, query builders prepend schema names in queries (e.g., `select * from "schema"."users"`). SQLite does not support schemas.
+
+### PostgreSQL
+
+```ts
+import { serial, text, pgSchema } from "drizzle-orm/pg-core";
+
+export const mySchema = pgSchema("my_schema");
+export const colors = mySchema.enum('colors', ['red', 'green', 'blue']);
+export const mySchemaUsers = mySchema.table('users', {
+  id: serial('id').primaryKey(),
+  name: text('name'),
+  color: colors('color').default('red'),
+});
+```
+
+Generates:
+```sql
+CREATE SCHEMA "my_schema";
+CREATE TYPE "my_schema"."colors" AS ENUM ('red', 'green', 'blue');
+CREATE TABLE "my_schema"."users" (
+  "id" serial PRIMARY KEY,
+  "name" text,
+  "color" "my_schema"."colors" DEFAULT 'red'
+);
+```
+
+### MySQL
+
+```ts
+import { int, text, mysqlSchema } from "drizzle-orm/mysql-core";
+
+export const mySchema = mysqlSchema("my_schema");
+export const mySchemaUsers = mySchema.table("users", {
+  id: int("id").primaryKey().autoincrement(),
+  name: text("name"),
+});
+```
+
+Generates:
+```sql
+CREATE SCHEMA "my_schema";
+CREATE TABLE "my_schema"."users" (
+  "id" serial PRIMARY KEY,
+  "name" text
+);
+```
+
+### SingleStore
+
+```ts
+import { int, text, singlestoreSchema } from "drizzle-orm/singlestore-core";
+
+export const mySchema = singlestoreSchema("my_schema");
+export const mySchemaUsers = mySchema.table("users", {
+  id: int("id").primaryKey().autoincrement(),
+  name: text("name"),
+});
+```
+
+Generates the same SQL as MySQL variant.

package/lovely-docs/drizzle-orm/seed-generators.md

@@ -0,0 +1,220 @@
+## Seed Generators Reference
+
+Generators are functions used with `drizzle-seed` to create test data. All generators support `arraySize` parameter to generate arrays of values.
+
+**Warning**: Using `arraySize` with `isUnique` generates unique individual values packed into arrays, not unique arrays.
+
+### Basic Generators
+
+**`default(defaultValue, arraySize)`** - Returns the same value each time.
+```ts
+funcs.default({ defaultValue: "post content", arraySize: 3 })
+```
+
+**`valuesFromArray(values, isUnique, arraySize)`** - Picks from given array. Values can be weighted: `{ weight: number; values: any[] }[]`
+```ts
+funcs.valuesFromArray({ 
+  values: ["Title1", "Title2", "Title3"],
+  isUnique: true,
+  arraySize: 3 
+})
+```
+
+**`intPrimaryKey()`** - Sequential integers starting from 1.
+```ts
+funcs.intPrimaryKey()
+```
+
+### Numeric Generators
+
+**`number(minValue, maxValue, precision, isUnique, arraySize)`** - Floating point numbers.
+- `precision`: 10 = 0.1 accuracy, 100 = 0.01 accuracy
+- Default `maxValue`: `precision * 1000` (non-unique) or `precision * count` (unique)
+- Default `minValue`: `-maxValue`
+
+```ts
+funcs.number({ minValue: 10, maxValue: 120, precision: 100, isUnique: false, arraySize: 3 })
+```
+
+**`int(minValue, maxValue, isUnique, arraySize)`** - Integers in range.
+- Default `maxValue`: `1000` (non-unique) or `count * 10` (unique)
+- Default `minValue`: `-maxValue`
+
+```ts
+funcs.int({ minValue: 0, maxValue: 100, isUnique: false, arraySize: 3 })
+```
+
+### Boolean & Temporal Generators
+
+**`boolean(arraySize)`** - True or false values.
+```ts
+funcs.boolean({ arraySize: 3 })
+```
+
+**`date(minDate, maxDate, arraySize)`** - Dates in range.
+- Defaults: `minDate: '2020-05-08'`, `maxDate: '2028-05-08'`
+- If only one date provided, the other is calculated by ±8 years
+
+```ts
+funcs.date({ minDate: "1990-01-01", maxDate: "2010-12-31", arraySize: 3 })
+```
+
+**`time(arraySize)`** - 24-hour format time.
+```ts
+funcs.time({ arraySize: 3 })
+```
+
+**`timestamp(arraySize)`** - Timestamps.
+```ts
+funcs.timestamp({ arraySize: 3 })
+```
+
+**`datetime(arraySize)`** - Datetime objects.
+```ts
+funcs.datetime({ arraySize: 3 })
+```
+
+**`year(arraySize)`** - Years in YYYY format.
+```ts
+funcs.year({ arraySize: 3 })
+```
+
+**`interval(isUnique, arraySize)`** - Time intervals (e.g., "1 year 12 days 5 minutes").
+```ts
+funcs.interval({ isUnique: true, arraySize: 3 })
+```
+
+### Data Type Generators
+
+**`json(arraySize)`** - JSON objects with random structure containing: email, name, isGraduated, hasJob, salary, startedWorking, visitedCountries (structure picked randomly).
+```ts
+funcs.json({ arraySize: 3 })
+```
+
+**`string(isUnique, arraySize)`** - Random strings.
+```ts
+funcs.string({ isUnique: false, arraySize: 3 })
+```
+
+**`uuid(arraySize)`** - v4 UUID strings.
+```ts
+funcs.uuid({ arraySize: 3 })
+```
+
+### Person & Location Generators
+
+**`firstName(isUnique, arraySize)`** - Person's first name.
+```ts
+funcs.firstName({ isUnique: true, arraySize: 3 })
+```
+
+**`lastName(isUnique, arraySize)`** - Person's last name.
+```ts
+funcs.lastName({ isUnique: false, arraySize: 3 })
+```
+
+**`fullName(isUnique, arraySize)`** - Person's full name.
+```ts
+funcs.fullName({ isUnique: true, arraySize: 3 })
+```
+
+**`email(arraySize)`** - Unique email addresses.
+```ts
+funcs.email({ arraySize: 3 })
+```
+
+**`phoneNumber(template | prefixes, generatedDigitsNumbers, arraySize)`** - Unique phone numbers.
+- Template mode: `template: "+(380) ###-####"` (# replaced with digits)
+- Prefix mode: `prefixes: ["+380 99", "+380 67"]`, `generatedDigitsNumbers: 7` or `[7, 7, 10]` per prefix
+
+```ts
+funcs.phoneNumber({ template: "+(380) ###-####", arraySize: 3 })
+funcs.phoneNumber({ prefixes: ["+380 99", "+380 67"], generatedDigitsNumbers: 7, arraySize: 3 })
+funcs.phoneNumber({ prefixes: ["+380 99", "+380 67", "+1"], generatedDigitsNumbers: [7, 7, 10], arraySize: 3 })
+```
+
+**`country(isUnique, arraySize)`** - Country names.
+```ts
+funcs.country({ isUnique: false, arraySize: 3 })
+```
+
+**`city(isUnique, arraySize)`** - City names.
+```ts
+funcs.city({ isUnique: false, arraySize: 3 })
+```
+
+**`streetAddress(isUnique, arraySize)`** - Street addresses.
+```ts
+funcs.streetAddress({ isUnique: false, arraySize: 3 })
+```
+
+**`postcode(isUnique, arraySize)`** - Postal codes.
+```ts
+funcs.postcode({ isUnique: true, arraySize: 3 })
+```
+
+**`state(arraySize)`** - US states.
+```ts
+funcs.state({ arraySize: 3 })
+```
+
+### Business & Content Generators
+
+**`jobTitle(arraySize)`** - Job titles.
+```ts
+funcs.jobTitle({ arraySize: 3 })
+```
+
+**`companyName(isUnique, arraySize)`** - Company names.
+```ts
+funcs.companyName({ isUnique: true, arraySize: 3 })
+```
+
+**`loremIpsum(sentencesCount, arraySize)`** - Lorem ipsum text.
+- Default `sentencesCount`: 1
+
+```ts
+funcs.loremIpsum({ sentencesCount: 2, arraySize: 3 })
+```
+
+### Geometric Generators
+
+**`point(minXValue, maxXValue, minYValue, maxYValue, isUnique, arraySize)`** - 2D points.
+- Default `maxXValue`/`maxYValue`: `10 * 1000` (non-unique) or `10 * count` (unique)
+- Default `minXValue`/`minYValue`: `-maxXValue`/`-maxYValue`
+
+```ts
+funcs.point({ 
+  minXValue: -5, maxXValue: 20, 
+  minYValue: 0, maxYValue: 30, 
+  isUnique: true, arraySize: 3 
+})
+```
+
+**`line(minAValue, maxAValue, minBValue, maxBValue, minCValue, maxCValue, isUnique, arraySize)`** - 2D lines (equation: a*x + b*y + c = 0).
+- Default ranges: `10 * 1000` (non-unique) or `10 * count` (unique)
+- Default min values: `-max` values
+
+```ts
+funcs.line({ 
+  minAValue: -5, maxAValue: 20,
+  minBValue: 0, maxBValue: 30,
+  minCValue: 0, maxCValue: 10,
+  isUnique: true, arraySize: 3 
+})
+```
+
+### Usage Pattern
+
+All generators are used within `seed()` refine callback:
+```ts
+import { seed } from "drizzle-seed";
+
+await seed(db, schema, { count: 1000 }).refine((funcs) => ({
+  tableName: {
+    columns: {
+      columnName: funcs.generatorName({ /* options */ }),
+    },
+  },
+}));
+```

package/lovely-docs/drizzle-orm/seed-limitations.md

@@ -0,0 +1,3 @@
+Type limitations for the third parameter in seed operations.
+
+The page documents constraints and type-related issues that developers may encounter when working with the third parameter of seeding functions in drizzle-orm. This covers type inference limitations, type safety concerns, and potential workarounds when the type system cannot properly infer or validate the third parameter.

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

@@ -0,0 +1,155 @@
+## Drizzle Seed
+
+TypeScript library for generating deterministic, realistic fake data using a seedable pseudorandom number generator (pRNG). Same seed always produces identical data, enabling reproducible testing and debugging.
+
+**Supported databases:** PostgreSQL, SQLite, MySQL (not SingleStore)
+
+**Requirements:** drizzle-orm@0.36.4 or higher
+
+### Installation
+```
+npm install drizzle-seed
+```
+
+### Basic Usage
+```ts
+import { pgTable, integer, text } from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { seed } from "drizzle-seed";
+
+const users = pgTable("users", {
+  id: integer().primaryKey(),
+  name: text().notNull(),
+});
+
+const db = drizzle(process.env.DATABASE_URL!);
+await seed(db, { users });  // Creates 10 users by default
+```
+
+### Options
+
+**`count`** - Number of entities to create (default: 10)
+```ts
+await seed(db, schema, { count: 1000 });
+```
+
+**`seed`** - Seed number for pRNG (different numbers generate different data)
+```ts
+await seed(db, schema, { seed: 12345 });
+```
+
+### Reset Database
+```ts
+import * as schema from "./schema.ts";
+import { reset } from "drizzle-seed";
+
+const db = drizzle(process.env.DATABASE_URL!);
+await reset(db, schema);
+```
+
+Reset strategies by dialect:
+- **PostgreSQL:** `TRUNCATE tableName1, tableName2, ... CASCADE;`
+- **MySQL:** Disables `FOREIGN_KEY_CHECKS`, runs `TRUNCATE` per table, re-enables checks
+- **SQLite:** Disables `foreign_keys` pragma, runs `DELETE FROM` per table, re-enables pragma
+
+### Refinements
+
+Use `.refine()` callback to customize generation behavior:
+
+```ts
+await seed(db, schema).refine((f) => ({
+  users: {
+    columns: { name: f.fullName() },
+    count: 20
+  }
+}));
+```
+
+Refinement properties:
+- **`columns`** - Override default generator for each column
+- **`count`** - Rows to insert (overrides global count)
+- **`with`** - Define related entities to create (one-to-many only)
+
+**Example 1:** Seed users with custom name generation
+```ts
+await seed(db, { users: schema.users }).refine((f) => ({
+  users: {
+    columns: { name: f.fullName() },
+    count: 20
+  }
+}));
+```
+
+**Example 2:** Seed users with 10 posts each
+```ts
+await seed(db, schema).refine((f) => ({
+  users: {
+    count: 20,
+    with: { posts: 10 }
+  }
+}));
+```
+
+**Example 3:** Custom int range and array values
+```ts
+await seed(db, schema).refine((f) => ({
+  users: {
+    count: 5,
+    columns: {
+      id: f.int({ minValue: 10000, maxValue: 20000, isUnique: true })
+    }
+  },
+  posts: {
+    count: 100,
+    columns: {
+      description: f.valuesFromArray({
+        values: ["text1", "text2", "text3"]
+      })
+    }
+  }
+}));
+```
+
+### Weighted Random
+
+Use weighted distributions for column values and related entity counts:
+
+**Column values with weights:**
+```ts
+await seed(db, schema).refine((f) => ({
+  orders: {
+    count: 5000,
+    columns: {
+      unitPrice: f.weightedRandom([
+        { weight: 0.3, value: f.int({ minValue: 10, maxValue: 100 }) },
+        { weight: 0.7, value: f.number({ minValue: 100, maxValue: 300, precision: 100 }) }
+      ])
+    }
+  }
+}));
+```
+
+**Related entity counts with weights:**
+```ts
+await seed(db, schema).refine((f) => ({
+  orders: {
+    with: {
+      details: [
+        { weight: 0.6, count: [1, 2, 3] },
+        { weight: 0.3, count: [5, 6, 7] },
+        { weight: 0.1, count: [8, 9, 10] }
+      ]
+    }
+  }
+}));
+```
+
+### Complex Example
+
+Full e-commerce schema with 10,000 customers, 200 employees, 50,000 orders with weighted detail counts, 1,000 suppliers, 5,000 products with weighted pricing, and order details with weighted discounts. Uses generators: `companyName()`, `fullName()`, `jobTitle()`, `streetAddress()`, `city()`, `postcode()`, `state()`, `country()`, `phoneNumber()`, `date()`, `int()`, `number()`, `loremIpsum()`, `valuesFromArray()`, `weightedRandom()`, `default()`.
+
+### Limitations
+
+- **`with` type inference:** TypeScript cannot properly infer table references with circular dependencies. The `with` option displays all tables; manually select the one with one-to-many relationship.
+- **`with` supports one-to-many only:** Can use `users with posts` but not `posts with users`.
+- **Third parameter in Drizzle tables:** No type support (works at runtime only).