@lunarhue/expo-wa-sqlite 0.0.1

package/lovely-docs/drizzle-orm/release_notes/v0.29.1_release_notes.md

@@ -0,0 +1,72 @@
+## Fixes
+
+- **withReplica**: Fixed argument forwarding when using the withReplica feature
+- **selectDistinctOn**: Fixed issue where selectDistinctOn was not working with multiple columns
+
+## New Features
+
+### Detailed JSDoc for Query Builders
+JSDoc documentation is now available for all query builders across all dialects, providing hints and documentation links directly in IDEs.
+
+### Aggregate Function Helpers
+New SQL helper functions for aggregation operations (typically used with GROUP BY):
+
+```ts
+// count
+await db.select({ value: count() }).from(users);
+await db.select({ value: count(users.id) }).from(users);
+
+// countDistinct
+await db.select({ value: countDistinct(users.id) }).from(users);
+
+// avg / avgDistinct
+await db.select({ value: avg(users.id) }).from(users);
+await db.select({ value: avgDistinct(users.id) }).from(users);
+
+// sum / sumDistinct
+await db.select({ value: sum(users.id) }).from(users);
+await db.select({ value: sumDistinct(users.id) }).from(users);
+
+// max / min
+await db.select({ value: max(users.id) }).from(users);
+await db.select({ value: min(users.id) }).from(users);
+```
+
+These are equivalent to using `sql` template with `.mapWith()` for type mapping.
+
+### ESLint Drizzle Plugin
+New package `eslint-plugin-drizzle` for enforcing best practices where type checking is insufficient.
+
+**Installation**:
+```
+npm install eslint eslint-plugin-drizzle
+npm install @typescript-eslint/eslint-plugin @typescript-eslint/parser
+```
+
+**Configuration** (`.eslintrc.yml`):
+```yaml
+root: true
+parser: '@typescript-eslint/parser'
+parserOptions:
+  project: './tsconfig.json'
+plugins:
+  - drizzle
+rules:
+  'drizzle/enforce-delete-with-where': "error"
+  'drizzle/enforce-update-with-where': "error"
+```
+
+Or use the `all`/`recommended` config:
+```yaml
+extends:
+  - "plugin:drizzle/all"
+```
+
+**Rules**:
+
+1. **enforce-delete-with-where**: Requires `.where()` clause in `.delete()` statements to prevent accidental deletion of all rows. Optionally configure `drizzleObjectName` to target specific objects:
+```json
+"drizzle/enforce-delete-with-where": ["error", { "drizzleObjectName": ["db"] }]
+```
+
+2. **enforce-update-with-where**: Requires `.where()` clause in `.update()` statements to prevent accidental updates of all rows. Same `drizzleObjectName` option available.

package/lovely-docs/drizzle-orm/release_notes/v0.29.2_release_notes.md

@@ -0,0 +1,95 @@
+## Bug Fixes
+- Improved planescale relational tests
+- Fixed string escaping for empty PgArrays
+- Fixed incorrect syntax for SQLite exists function
+- Fixed date handling in AWS Data API
+- Fixed Hermes mixins constructor issue
+
+## ESLint Plugin v0.2.3
+- Added support for Drizzle objects retrieved from functions
+- Improved error message context in suggestions
+
+## New: Expo SQLite Driver
+
+Install packages:
+```bash
+npm install drizzle-orm expo-sqlite@next
+```
+
+Basic usage:
+```ts
+import { drizzle } from "drizzle-orm/expo-sqlite";
+import { openDatabaseSync } from "expo-sqlite";
+
+const expoDb = openDatabaseSync("db.db");
+const db = drizzle(expoDb);
+
+await db.select().from(...);
+// or
+db.select().from(...).then(...);
+// or
+db.select().from(...).all();
+```
+
+For migrations support, configure Babel and Metro:
+
+**babel.config.js:**
+```ts
+module.exports = function(api) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo'],
+    plugins: [["inline-import", { "extensions": [".sql"] }]]
+  };
+};
+```
+
+**metro.config.js:**
+```ts
+const { getDefaultConfig } = require('expo/metro-config');
+const config = getDefaultConfig(__dirname);
+config.resolver.sourceExts.push('sql');
+module.exports = config;
+```
+
+**drizzle.config.ts:**
+```ts
+import type { Config } from 'drizzle-kit';
+
+export default {
+  schema: './db/schema.ts',
+  out: './drizzle',
+  dialect: 'sqlite',
+  driver: 'expo',
+} satisfies Config;
+```
+
+Generate migrations:
+```bash
+npx drizzle-kit generate
+```
+
+Use migrations in **App.tsx:**
+```ts
+import { drizzle } from "drizzle-orm/expo-sqlite";
+import { openDatabaseSync } from "expo-sqlite";
+import { useMigrations } from 'drizzle-orm/expo-sqlite/migrator';
+import migrations from './drizzle/migrations';
+
+const expoDb = openDatabaseSync("db.db");
+const db = drizzle(expoDb);
+
+export default function App() {
+  const { success, error } = useMigrations(db, migrations);
+
+  if (error) {
+    return <View><Text>Migration error: {error.message}</Text></View>;
+  }
+
+  if (!success) {
+    return <View><Text>Migration is in progress...</Text></View>;
+  }
+
+  return ...your application component;
+}
+```

package/lovely-docs/drizzle-orm/release_notes/v0.29.3_release.md

@@ -0,0 +1,7 @@
+## v0.29.3 Release
+
+**Fix:** Expo peer dependencies are now optional.
+
+This release addresses an issue where Expo peer dependencies were required, which could cause problems for users not using Expo. The fix makes these dependencies optional, allowing developers to use DrizzleORM with Expo SQLite without unnecessary dependency constraints.
+
+Related: Expo documentation and Expo SQLite integration guide.

package/lovely-docs/drizzle-orm/release_notes/v0.29.4_release_notes.md

@@ -0,0 +1,40 @@
+## Neon HTTP Batch Support
+
+Added support for batching multiple queries in a single request using Neon's HTTP driver:
+
+```ts
+import { neon } from '@neondatabase/serverless';
+import { drizzle } from 'drizzle-orm/neon-http';
+import { usersTable } from './schema';
+
+const sql = neon(process.env.DRIZZLE_DATABASE_URL!);
+const db = drizzle(sql);
+
+const batchResponse = await db.batch([
+	db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+	db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+	db.query.usersTable.findMany({}),
+	db.query.usersTable.findFirst({}),
+]);
+```
+
+The batch method returns a tuple with typed results for each query in the batch.
+
+## PlanetScale Client Instance Update
+
+Updated PlanetScale integration to use `Client` instance instead of `connect()` function:
+
+```ts
+import { Client } from '@planetscale/database';
+import { drizzle } from 'drizzle-orm/planetscale-serverless';
+
+const client = new Client({
+	host: process.env['DATABASE_HOST'],
+	username: process.env['DATABASE_USERNAME'],
+	password: process.env['DATABASE_PASSWORD'],
+});
+
+const db = drizzle(client);
+```
+
+**Breaking change warning**: Version 0.30.0 will require `Client` instances and reject `connect()` results. A deprecation warning is shown in v0.29.4 when using `connect()`. Migrate now to avoid runtime errors.

package/lovely-docs/drizzle-orm/release_notes/v0.29.5_release_notes.md

@@ -0,0 +1,69 @@
+## WITH Statements for INSERT, UPDATE, DELETE
+
+You can now use `WITH` (CTE) clauses with INSERT, UPDATE, and DELETE statements.
+
+Example with DELETE:
+```ts
+const averageAmount = db.$with('average_amount').as(
+	db.select({ value: sql`avg(${orders.amount})`.as('value') }).from(orders),
+);
+
+const result = await db
+	.with(averageAmount)
+	.delete(orders)
+	.where(gt(orders.amount, sql`(select * from ${averageAmount})`))
+	.returning({ id: orders.id });
+```
+
+Generates:
+```sql
+with "average_amount" as (select avg("amount") as "value" from "orders") 
+delete from "orders" 
+where "orders"."amount" > (select * from "average_amount") 
+returning "id";
+```
+
+## Custom Migrations Table and Schema
+
+**Custom migrations table name** (all databases):
+```ts
+await migrate(db, {
+	migrationsFolder: './drizzle',
+	migrationsTable: 'my_migrations',
+});
+```
+
+By default migrations are stored in `__drizzle_migrations` table (in `drizzle` schema for PostgreSQL).
+
+**Custom migrations schema** (PostgreSQL only):
+```ts
+await migrate(db, {
+	migrationsFolder: './drizzle',
+	migrationsSchema: 'custom',
+});
+```
+
+## SQLite Proxy Batch and Relational Queries
+
+SQLite proxy driver now supports:
+- Relational queries: `.query.findFirst()` and `.query.findMany()`
+- Batch requests via `db.batch([])`
+
+Batch callback setup:
+```ts
+import { drizzle } from 'drizzle-orm/sqlite-proxy';
+
+type ResponseType = { rows: any[][] | any[] }[];
+
+const db = drizzle(
+	async (sql, params, method) => {
+		// single query logic
+	},
+	async (queries: { sql: string; params: any[]; method: 'all' | 'run' | 'get' | 'values' }[]) => {
+		const result: ResponseType = await axios.post('http://localhost:3000/batch', { queries });
+		return result;
+	},
+);
+```
+
+Response must be an array of raw values in the same order as sent queries.

package/lovely-docs/drizzle-orm/release_notes/v0.30.0_release_notes.md

@@ -0,0 +1,31 @@
+## Breaking Changes: Postgres Timestamp Handling
+
+The `postgres.js` driver instance has been modified to always return strings for dates. Drizzle then maps these to either strings or Date objects based on the selected `mode`. This is a breaking change that affects how timestamps are handled.
+
+**Key Impact:**
+- Timestamps with and without timezone now always use `.toISOString()` for mapping to the driver
+- All `postgres.js` clients passed to Drizzle will have mutated behavior - dates will always be strings in responses
+- If you were expecting specific timestamp responses, behavior has changed
+
+**Parser Override for postgres.js:**
+```ts
+const transparentParser = (val: any) => val;
+
+// Override postgres.js default date parsers
+for (const type of ['1184', '1082', '1083', '1114']) {
+	client.options.parsers[type as any] = transparentParser;
+	client.options.serializers[type as any] = transparentParser;
+}
+```
+
+The team notes this is not ideal since the driver client gets mutated. They're working with the `postgres.js` library creator to enable per-query mapping interceptors instead.
+
+## Fixes
+
+Multiple timestamp and date-related issues resolved:
+- Timestamp with mode string returning Date object instead of string
+- Inconsistent date/datetime handling across drivers
+- Type mismatches (columns showing string type but returning Date objects)
+- PostgreSQL timezone-related conversion issues
+- Millisecond loss during timestamp inserts
+- Invalid dates from relational queries

package/lovely-docs/drizzle-orm/release_notes/v0.30.10_release.md

@@ -0,0 +1,18 @@
+## New Features
+
+### `.if()` function for WHERE expressions
+
+Conditional WHERE clauses using `.if()` method:
+
+```ts
+await db
+  .select()
+  .from(posts)
+  .where(gt(posts.views, views).if(views > 100));
+```
+
+The `.if()` function is available on all WHERE expressions and allows conditional filtering based on runtime values.
+
+## Bug Fixes
+
+- Fixed internal mappings for sessions `.all()`, `.values()`, `.execute()` functions in AWS DataAPI

package/lovely-docs/drizzle-orm/release_notes/v0.30.1_release_notes.md

@@ -0,0 +1,16 @@
+## OP-SQLite Driver Support
+
+New driver added for OP-SQLite. Initialize with:
+
+```ts
+import { open } from '@op-engineering/op-sqlite';
+import { drizzle } from 'drizzle-orm/op-sqlite';
+
+const opsqlite = open({ name: 'myDB' });
+const db = drizzle(opsqlite);
+await db.select().from(users);
+```
+
+## Fixes
+
+- Migration hook fixed for Expo driver

package/lovely-docs/drizzle-orm/release_notes/v0.30.2_release_notes.md

@@ -0,0 +1,7 @@
+## Improvements
+
+LibSQL migrations now use batch execution instead of transactions. Batch operations execute multiple SQL statements sequentially within an implicit transaction - the backend commits all changes on success or rolls back completely on any failure.
+
+## Fixes
+
+- Fixed findFirst query for bun:sqlite

package/lovely-docs/drizzle-orm/release_notes/v0.30.3_release_notes.md

@@ -0,0 +1,8 @@
+## New Features
+
+- Added raw query support (`db.execute(...)`) to batch API in Neon HTTP driver
+
+## Fixes
+
+- Fixed `@neondatabase/serverless` HTTP driver types issue
+- Fixed sqlite-proxy driver `.run()` result

package/lovely-docs/drizzle-orm/release_notes/v0.30.5_release_notes.md

@@ -0,0 +1,20 @@
+## `$onUpdate` functionality for PostgreSQL, MySQL and SQLite
+
+Adds dynamic update values to columns. The `$onUpdate()` function is called when a row is updated, and its returned value is used as the column value if none is provided. If no `default` or `$defaultFn` is set, the function is also called on insert.
+
+Note: This is runtime-only behavior in drizzle-orm and does not affect drizzle-kit.
+
+Example:
+```ts
+const usersOnUpdate = pgTable('users_on_update', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  updateCounter: integer('update_counter').default(sql`1`).$onUpdateFn(() => sql`update_counter + 1`),
+  updatedAt: timestamp('updated_at', { mode: 'date', precision: 3 }).$onUpdate(() => new Date()),
+  alwaysNull: text('always_null').$type<string | null>().$onUpdate(() => null),
+});
+```
+
+## Fixes
+
+- Insertions on columns with smallserial datatype are now correctly non-optional (issue #1848)

package/lovely-docs/drizzle-orm/release_notes/v0.30.7_release.md

@@ -0,0 +1,5 @@
+## Fixes
+
+- Added mappings for `@vercel/postgres` package. Vercel Postgres is a serverless PostgreSQL database service. To get started with Drizzle and Vercel Postgres, refer to the PostgreSQL getting started documentation section on Vercel Postgres.
+
+- Fixed interval mapping for `neon` drivers (issue #1542). Neon is a serverless PostgreSQL platform. To get started with Drizzle and Neon, refer to the PostgreSQL getting started documentation section on Neon.

package/lovely-docs/drizzle-orm/release_notes/v0.30.8_release_notes.md

@@ -0,0 +1,36 @@
+## New Features
+
+**Custom schema support for Postgres enums:**
+```ts
+import { pgSchema } from 'drizzle-orm/pg-core';
+
+const mySchema = pgSchema('mySchema');
+const colors = mySchema.enum('colors', ['red', 'green', 'blue']);
+```
+
+## Fixes
+
+**D1 migrate() function:** Changed to use batch API for better performance.
+
+**Postgres `.onConflictDoUpdate` method:** Split `where` clause into `setWhere` and `targetWhere` to support both where cases in on conflict clause.
+```ts
+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'`
+  });
+```
+
+**Postgres `.onConflictDoNothing` method:** Fixed query generation for `where` clause placement.
+
+**AWS Data API driver:** Fixed multiple issues including inserting and updating array values.

package/lovely-docs/drizzle-orm/release_notes/v0.30.9_release.md

@@ -0,0 +1,29 @@
+## New Features
+
+**Enhanced `.onConflictDoUpdate()` in SQLite**: Added `setWhere` and `targetWhere` fields to replace the single `where` field, enabling more granular control over conflict resolution:
+
+```ts
+// Using targetWhere to filter which conflicts to handle
+await db.insert(employees)
+  .values({ employeeId: 123, name: 'John Doe' })
+  .onConflictDoUpdate({
+    target: employees.employeeId,
+    targetWhere: sql`name <> 'John Doe'`,
+    set: { name: sql`excluded.name` }
+  });
+
+// Using setWhere to conditionally apply updates
+await db.insert(employees)
+  .values({ employeeId: 123, name: 'John Doe' })
+  .onConflictDoUpdate({
+    target: employees.employeeId,
+    set: { name: 'John Doe' },
+    setWhere: sql`name <> 'John Doe'`
+  });
+```
+
+**Schema introspection**: Added `db._.fullSchema` to access schema information from Drizzle instances.
+
+## Fixes
+
+- Fixed migrator in AWS Data API

package/lovely-docs/drizzle-orm/release_notes/v0.31.0_release_notes.md

@@ -0,0 +1,186 @@
+## Breaking Changes
+
+**PostgreSQL indexes API was changed** to align with PostgreSQL documentation. The previous API didn't support SQL expressions in `.on()`, conflated `.using()` and `.on()`, and placed ordering modifiers on the index instead of per-column.
+
+Previous API:
+```ts
+index('name')
+  .on(table.column1, table.column2)
+  .using(sql``)
+  .asc() / .desc()
+  .nullsFirst() / .nullsLast()
+  .where(sql``)
+```
+
+New API:
+```ts
+// With .on()
+index('name')
+  .on(table.column1.asc(), table.column2.nullsFirst())
+  .concurrently()
+  .where(sql``)
+  .with({ fillfactor: '70' })
+
+// With .using()
+index('name')
+  .using('btree', table.column1.asc(), sql`lower(${table.column2})`, table.column1.op('text_ops'))
+  .where(sql``)
+  .with({ fillfactor: '70' })
+```
+
+Requires `drizzle-kit@0.22.0` or higher.
+
+## New Features
+
+### pg_vector extension support
+
+Define vector indexes and use vector distance functions:
+
+```ts
+const table = pgTable('items', {
+    embedding: vector('embedding', { dimensions: 3 })
+}, (table) => ({
+    l2: index('l2_index').using('hnsw', table.embedding.op('vector_l2_ops')),
+    ip: index('ip_index').using('hnsw', table.embedding.op('vector_ip_ops')),
+    cosine: index('cosine_index').using('hnsw', table.embedding.op('vector_cosine_ops')),
+    l1: index('l1_index').using('hnsw', table.embedding.op('vector_l1_ops')),
+    hamming: index('hamming_index').using('hnsw', table.embedding.op('bit_hamming_ops')),
+    jaccard: index('jaccard_index').using('hnsw', table.embedding.op('bit_jaccard_ops'))
+}))
+```
+
+Helper functions for queries:
+```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') // <%>
+```
+
+Query examples:
+```ts
+db.select().from(items).orderBy(l2Distance(items.embedding, [3,1,2]))
+db.select({ distance: l2Distance(items.embedding, [3,1,2]) }).from(items)
+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)
+```
+
+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)}`;
+}
+```
+
+### New PostgreSQL types: point and line
+
+**point** type with two modes:
+```ts
+const items = pgTable('items', {
+ point: point('point'), // tuple mode: [1,2]
+ pointObj: point('point_xy', { mode: 'xy' }), // xy mode: { x: 1, y: 2 }
+});
+```
+
+**line** type with two modes:
+```ts
+const items = pgTable('items', {
+ line: line('line'), // tuple mode: [1,2,3]
+ lineObj: line('line_abc', { mode: 'abc' }), // abc mode: { a: 1, b: 2, c: 3 }
+});
+```
+
+### PostGIS extension support
+
+**geometry** type from postgis:
+```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 }),
+});
+```
+
+Modes: `tuple` (default, maps to [x,y]) and `xy` (maps to { x, y }). Type defaults to `point` but accepts any string.
+
+## Drizzle Kit v0.22.0 Updates
+
+### New type support
+- `point` and `line` from PostgreSQL
+- `vector` from pg_vector extension
+- `geometry` from PostGIS extension
+
+### extensionsFilters config parameter
+
+Skip tables created by extensions:
+```ts
+export default defineConfig({
+  dialect: "postgresql",
+  extensionsFilters: ["postgis"], // skips geography_columns, geometry_columns, spatial_ref_sys
+})
+```
+
+### SSL configuration improvements
+
+Full SSL parameter support:
+```ts
+// PostgreSQL
+export default defineConfig({
+  dialect: "postgresql",
+  dbCredentials: {
+    ssl: true, // or "require" | "allow" | "prefer" | "verify-full" | node:tls options
+  }
+})
+
+// MySQL
+export default defineConfig({
+  dialect: "mysql",
+  dbCredentials: {
+    ssl: "", // string | mysql2 SslOptions
+  }
+})
+```
+
+### Normalized SQLite URLs
+
+libsql and better-sqlite3 drivers now accept both file path patterns and normalize them correctly.
+
+### MySQL and SQLite index-as-expression behavior
+
+Expressions are no longer escaped in strings, columns are properly handled:
+```ts
+export const users = sqliteTable('users', {
+    id: integer('id').primaryKey(),
+    email: text('email').notNull(),
+}, (table) => ({
+    emailUniqueIndex: uniqueIndex('emailUniqueIndex').on(sql`lower(${table.email})`),
+}));
+
+// Before: CREATE UNIQUE INDEX `emailUniqueIndex` ON `users` (`lower("users"."email")`);
+// Now: CREATE UNIQUE INDEX `emailUniqueIndex` ON `users` (lower("email"));
+```
+
+### Index limitations
+
+Must specify index name manually if using expressions:
+```ts
+index().on(table.id, table.email) // auto-named, works
+index('my_name').on(table.id, table.email) // works
+index().on(sql`lower(${table.email})`) // error
+index('my_name').on(sql`lower(${table.email})`) // works
+```
+
+Push won't generate statements if these fields change in existing indexes: expressions in `.on()`/`.using()`, `.where()` statements, or `.op()` operator classes. For changes, comment out the index, push, uncomment and modify, then push again. Generate command has no such limitations.
+
+### Bug fixes
+- Multiple constraints not added (only first generated)
+- Drizzle Studio connection termination errors
+- SQLite local migrations execution
+- Unknown '--config' option errors

package/lovely-docs/drizzle-orm/release_notes/v0.31.2_tidb_cloud_serverless_support.md

@@ -0,0 +1,16 @@
+## TiDB Cloud Serverless Driver Support
+
+Added support for TiDB Cloud Serverless driver in v0.31.2.
+
+**Usage:**
+
+```ts
+import { connect } from '@tidbcloud/serverless';
+import { drizzle } from 'drizzle-orm/tidb-serverless';
+
+const client = connect({ url: '...' });
+const db = drizzle(client);
+await db.select().from(...);
+```
+
+Initialize a TiDB Cloud Serverless client with a connection URL, pass it to `drizzle()` from the `tidb-serverless` module, then use standard Drizzle ORM queries.