@lunarhue/expo-wa-sqlite 0.0.1

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

@@ -0,0 +1,139 @@
+## Overview
+Open source TypeScript ORM with fully typed SQL schema in-code. Supports PostgreSQL with MySQL and SQLite coming soon.
+
+## Schema Definition
+Define tables as classes extending `PgTable` with typed columns:
+```ts
+export const popularityEnum = createEnum({ alias: 'popularity', values: ['unknown', 'known', 'popular'] });
+
+export class CountriesTable extends PgTable<CountriesTable> {
+  id = this.serial("id").primaryKey();
+  name = this.varchar("name", { size: 256 })
+  nameIndex = this.uniqueIndex(this.name)
+  public tableName(): string { return 'countries'; }
+}
+
+export class CitiesTable extends PgTable<CitiesTable> {
+  id = this.serial("id").primaryKey();
+  name = this.varchar("name", { size: 256 })
+  countryId = this.int("country_id").foreignKey(CountriesTable, (country) => country.id)
+  popularity = this.type(popularityEnum, "popularity")
+  public tableName(): string { return 'cities'; }
+}
+```
+
+## Connection & Basic Queries
+```ts
+import { drizzle } from 'drizzle-orm'
+
+export class UsersTable extends PgTable<UsersTable> {
+  public id = this.serial('id').primaryKey();
+  public fullName = this.text('full_name');
+  public phone = this.varchar('phone', { size: 256 });
+  public tableName(): string { return 'users'; }
+}
+export type User = InferType<UsersTable>
+
+const db = await drizzle.connect("postgres://user:password@host:port/db");
+const usersTable = new UsersTable(db);
+const users: User[] = await usersTable.select().execute();
+```
+
+## Filtering & Selection
+```ts
+// WHERE with filters
+await table.select().where(eq(table.id, 42)).execute();
+await table.select().where(and([eq(table.id, 42), eq(table.name, "Dan")])).execute();
+await table.select().where(or([eq(table.id, 42), eq(table.id, 1)])).execute();
+
+// Partial select
+const result = await table.select({
+  mapped1: table.id,
+  mapped2: table.name,
+}).execute();
+
+// Pagination & ordering
+await table.select().limit(10).offset(10).execute()
+await table.select().orderBy((table) => table.name, Order.ASC).execute()
+await table.select().orderBy((table) => table.name, Order.DESC).execute()
+```
+
+## Insert, Update, Delete
+```ts
+await usersTable.insert({ name: "Andrew", createdAt: new Date() }).execute();
+await usersTable.insertMany([
+  { name: "Andrew", createdAt: new Date() },
+  { name: "Dan", createdAt: new Date() }
+]).execute();
+await usersTable.update().where(eq(usersTable.name, 'Dan')).set({ name: 'Mr. Dan' }).execute();
+await usersTable.delete().where(eq(usersTable.name, 'Dan')).execute();
+```
+
+## Joins
+Fully typed joins prevent mistakes at compile time:
+```ts
+const result = await citiesTable.select()
+  .leftJoin(usersTable, (cities, users) => eq(cities.userId, users.id))
+  .where((cities, users) => eq(cities.id, 1))
+  .execute();
+const citiesWithUsers: { city: City, user: User }[] = result.map((city, user) => ({ city, user }));
+```
+
+## Many-to-Many Relationships
+```ts
+export class UsersTable extends PgTable<UsersTable> {
+  id = this.serial("id").primaryKey();
+  name = this.varchar("name");
+}
+export class ChatGroupsTable extends PgTable<ChatGroupsTable> {
+  id = this.serial("id").primaryKey();
+}
+export class ManyToManyTable extends PgTable<ManyToManyTable> {
+  userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onDelete: 'CASCADE' });
+  groupId = this.int('group_id').foreignKey(ChatGroupsTable, (table) => table.id, { onDelete: 'CASCADE' });
+}
+
+const usersWithUserGroups = await manyToManyTable.select()
+  .leftJoin(usersTable, (manyToMany, users) => eq(manyToManyTable.userId, users.id))
+  .leftJoin(chatGroupsTable, (manyToMany, _users, chatGroups) => eq(manyToManyTable.groupId, chatGroups.id))
+  .where((manyToMany, _users, userGroups) => eq(userGroups.id, 1))
+  .execute();
+```
+
+## Migrations
+CLI tool generates migrations automatically from TypeScript schema, handling renames and deletes with prompts.
+
+Schema:
+```ts
+export class UsersTable extends PgTable<UsersTable> {
+  public id = this.serial("id").primaryKey();
+  public fullName = this.varchar("full_name", { size: 256 });
+  public fullNameIndex = this.index(this.fullName);
+  public tableName(): string { return "users"; }
+}
+export class AuthOtpTable extends PgTable<AuthOtpTable> {
+  public id = this.serial("id").primaryKey();
+  public phone = this.varchar("phone", { size: 256 });
+  public userId = this.int("user_id").foreignKey(UsersTable, (t) => t.id);
+  public tableName(): string { return "auth_otp"; }
+}
+```
+
+Generated SQL:
+```sql
+CREATE TABLE IF NOT EXISTS auth_otp (
+    "id" SERIAL PRIMARY KEY,
+    "phone" character varying(256),
+    "user_id" INT
+);
+CREATE TABLE IF NOT EXISTS users (
+    "id" SERIAL PRIMARY KEY,
+    "full_name" character varying(256)
+);
+DO $$ BEGIN
+ ALTER TABLE auth_otp ADD CONSTRAINT auth_otp_user_id_fkey FOREIGN KEY ("user_id") REFERENCES users(id);
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+CREATE INDEX IF NOT EXISTS users_full_name_index ON users (full_name);
+```

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

@@ -0,0 +1,86 @@
+## PostgreSQL Schemas
+Declare PostgreSQL schemas and create tables within them:
+```ts
+import { pgSchema } from "drizzle-orm-pg";
+export const mySchema = pgSchema("my_schema");
+export const users = mySchema("users", {
+  id: serial("id").primaryKey(),
+  name: text("name"),
+  email: text("email"),
+});
+```
+Generates:
+```sql
+CREATE SCHEMA "my_schema";
+CREATE TABLE IF NOT EXISTS "my_schema"."users" (
+  "id" serial PRIMARY KEY NOT NULL,
+  "name" text,
+  "email" text
+);
+```
+drizzle-kit auto-generates migrations: `drizzle-kit generate:pg --schema=src/schema.ts --out=migrations/`
+
+## MySQL Databases/Schemas
+Similar schema support for MySQL:
+```ts
+import { mysqlSchema } from "drizzle-orm-mysql";
+const mySchema = mysqlSchema("my_schema");
+const users = mySchema("users", {
+  id: serial("id").primaryKey(),
+  name: text("name"),
+  email: text("email"),
+});
+```
+Generates:
+```sql
+CREATE DATABASE `my_schema`;
+CREATE TABLE `my_schema`.`users` (
+  `id` serial PRIMARY KEY NOT NULL,
+  `name` text,
+  `email` text
+);
+```
+Command: `drizzle-kit generate:mysql --schema=src/schema.ts --out=migrations/`
+
+## PostgreSQL Introspection
+Pull existing PostgreSQL database schema automatically with drizzle-kit. Supports enums, tables with native/non-native columns, indexes, foreign keys, self-references, cyclic foreign keys, and schemas:
+```shell
+drizzle-kit introspect:pg --out=migrations/ --connectionString=postgresql://user:pass@host:port/db_name
+```
+Generates complete `schema.ts` with all detected types, enums, tables, columns, defaults, and relationships including cyclic references and self-references.
+
+## Postgres.js Driver Support
+Full support for postgres.js driver:
+```ts
+import { pgTable, serial, text, varchar } from "drizzle-orm-pg";
+import { drizzle } from "drizzle-orm-pg/postgres.js";
+import postgres from "postgres";
+
+export const users = pgTable("users", {
+  id: serial("id").primaryKey(),
+  fullName: text("full_name"),
+  phone: varchar("phone", { length: 256 }),
+});
+
+const client = postgres(connectionString);
+const db = drizzle(client);
+const allUsers = await db.select(users);
+```
+
+## Custom Types
+Create non-native PostgreSQL or MySQL types:
+```ts
+const customText = customType<{ data: string }>({
+  dataType() { return "text"; }
+});
+
+// PostgreSQL
+const pgUsersTable = pgTable("users", {
+  name: customText("name").notNull(),
+});
+
+// MySQL
+const mysqlUsersTable = mysqlTable("users", {
+  name: customText("name").notNull(),
+});
+```

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

@@ -0,0 +1,5 @@
+## Bug Fixes
+
+**PostgreSQL schemaFilter bug**: Fixed an issue where the `schemaFilter` object in push and introspect commands was incorrectly detecting enums in schemas that were not defined in the filter.
+
+**drizzle-kit up command**: Fixed the `drizzle-kit up` command to work correctly starting from the sequences release.

package/lovely-docs/drizzle-orm/release_notes/v0.27.2_-_unique_constraints_support.md

@@ -0,0 +1,66 @@
+## UNIQUE Constraints Support Added
+
+Support for `UNIQUE` constraints across PostgreSQL, MySQL, and SQLite databases.
+
+### PostgreSQL
+Single-column constraints defined at column level with optional custom name:
+```ts
+const table = pgTable('table', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull().unique(),
+  state: char('state', { length: 2 }).unique('custom'),
+  field: char('field', { length: 2 }).unique('custom_field', { nulls: 'not distinct' }),
+});
+```
+
+Multi-column constraints defined in table config with `nullsNotDistinct()` option:
+```ts
+const table = pgTable('table', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  state: char('state', { length: 2 }),
+}, (t) => ({
+  first: unique('custom_name').on(t.name, t.state).nullsNotDistinct(),
+  second: unique('custom_name1').on(t.name, t.state),
+}));
+```
+
+PostgreSQL supports `NULLS NOT DISTINCT` option to restrict multiple NULL values.
+
+### MySQL
+Same syntax as PostgreSQL but without `NULLS NOT DISTINCT` support:
+```ts
+const table = mysqlTable('table', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull().unique(),
+  state: text('state').unique('custom'),
+});
+
+const table = mysqlTable('cities1', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  state: text('state'),
+}, (t) => ({
+  first: unique().on(t.name, t.state),
+  second: unique('custom_name1').on(t.name, t.state),
+}));
+```
+
+### SQLite
+Unique constraints implemented as unique indexes. Supports optional naming:
+```ts
+const table = sqliteTable('table', {
+  id: int('id').primaryKey(),
+  name: text('name').notNull().unique(),
+  state: text('state').unique('custom'),
+});
+
+const table = sqliteTable('table', {
+  id: int('id').primaryKey(),
+  name: text('name').notNull(),
+  state: text('state'),
+}, (t) => ({
+  first: unique().on(t.name, t.state),
+  second: unique('custom').on(t.name, t.state),
+}));
+```

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

@@ -0,0 +1,80 @@
+## Breaking Changes
+
+### Removed support for filtering by nested relations
+The `table` object in the `where` callback no longer includes fields from `with` and `extras`. This change improves relational query efficiency.
+
+```ts
+// This no longer works:
+const usersWithPosts = await db.query.users.findMany({
+  where: (table, { sql }) => (sql`json_array_length(${table.posts}) > 0`),
+  with: { posts: true },
+});
+```
+
+Workarounds: apply filters manually after fetching, or use the core API.
+
+### Added Relational Queries `mode` config for `mysql2` driver
+Relational queries use lateral joins which PlanetScale doesn't support. Specify the mode when creating the connection:
+
+```ts
+const db = drizzle({ client, schema, mode: 'planetscale' });
+// or
+const db = drizzle({ client, schema, mode: 'default' }); // for regular MySQL
+```
+
+## Performance Improvements
+
+### IntelliSense performance for large schemas
+Optimized internal types resulting in **430% speed up** for IntelliSense on schemas with 85 tables, 666 columns, 26 enums, 172 indexes, and 133 foreign keys.
+
+### Relational Queries Performance and Read Usage
+Completely rewrote query generation strategy:
+1. **Lateral Joins**: Uses "LEFT JOIN LATERAL" for efficient data retrieval; MySQL PlanetScale and SQLite use simple subquery selects
+2. **Selective Data Retrieval**: Only fetches necessary columns, reducing dataset size
+3. **Reduced Aggregations**: Uses `json_build_array` directly within lateral joins instead of multiple aggregation functions
+4. **Simplified Grouping**: Removed GROUP BY clause as lateral joins handle aggregation more efficiently
+
+Example query transformation:
+
+```ts
+const items = await db.query.comments.findMany({
+  limit,
+  orderBy: comments.id,
+  with: {
+    user: { columns: { name: true } },
+    post: {
+      columns: { title: true },
+      with: { user: { columns: { name: true } } },
+    },
+  },
+});
+```
+
+**New query** (with lateral joins):
+```sql
+select "comments"."id", "comments"."user_id", "comments"."post_id", "comments"."content",
+       "comments_user"."data" as "user", "comments_post"."data" as "post"
+from "comments"
+left join lateral (select json_build_array("comments_user"."name") as "data"
+                   from (select * from "users" "comments_user"
+                         where "comments_user"."id" = "comments"."user_id" limit 1) "comments_user") "comments_user" on true
+left join lateral (select json_build_array("comments_post"."title", "comments_post_user"."data") as "data"
+                   from (select * from "posts" "comments_post"
+                         where "comments_post"."id" = "comments"."post_id" limit 1) "comments_post"
+                   left join lateral (select json_build_array("comments_post_user"."name") as "data"
+                                      from (select * from "users" "comments_post_user"
+                                            where "comments_post_user"."id" = "comments_post"."user_id" limit 1) "comments_post_user") "comments_post_user" on true) "comments_post" on true
+order by "comments"."id" limit 1
+```
+
+**Old query** (with GROUP BY and aggregations) - significantly more complex with multiple CASE statements and json_agg calls.
+
+## New Features
+
+### Insert rows with default values for all columns
+Provide empty objects to insert rows with all default values:
+
+```ts
+await db.insert(usersTable).values({});        // Insert 1 row with all defaults
+await db.insert(usersTable).values([{}, {}]);  // Insert 2 rows with all defaults
+```

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

@@ -0,0 +1,7 @@
+## v0.28.1 Release
+
+**Release Date:** August 7, 2023
+
+### Fixes
+
+Fixed Postgres array-related issues that were introduced in version 0.28.0. This patch addresses problems reported in issues #983 and #992.

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

@@ -0,0 +1,18 @@
+## v0.28.2 Release
+
+### Community Contributions
+This release includes contributions from the community.
+
+### Internal Changes
+- Added comprehensive test suite for d1
+- Fixed documentation issues
+
+### Bug Fixes
+- **MySQL timestamp milliseconds**: Fixed truncation issue where milliseconds were being lost in timestamp values
+- **SQLite `.get()` method**: Corrected type signature for sqlite-based dialects (issue #565)
+- **SQLite proxy**: Fixed bug causing queries to execute twice
+
+### New Features
+- **Typebox support**: Added official support for Typebox package integration via new `drizzle-typebox` package
+  - Enables type-safe schema validation using Typebox
+  - See `/docs/typebox` for usage examples and documentation

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

@@ -0,0 +1,48 @@
+## Fixes
+- Fixed sqlite-proxy and SQL.js `.get()` response when result is empty
+
+## New Features
+
+### SQLite Simplified Query API
+Added simplified query API for SQLite.
+
+### Column Builder Methods: `.$defaultFn()` / `.$default()`
+Define runtime default values for columns with custom logic. Available for PostgreSQL, MySQL, and SQLite.
+
+```ts
+import { varchar, mysqlTable } from "drizzle-orm/mysql-core";
+import { createId } from '@paralleldrive/cuid2';
+
+const table = mysqlTable('table', {
+  id: varchar('id', { length: 128 }).$defaultFn(() => createId()),
+});
+```
+
+Note: Runtime defaults only affect drizzle-orm behavior, not drizzle-kit.
+
+### Table Model Type Inference: `$inferSelect` / `$inferInsert`
+Convenient methods for inferring table types. Replaces deprecated `InferModel`.
+
+```ts
+import { InferSelectModel, InferInsertModel } from 'drizzle-orm'
+
+const usersTable = pgTable('users', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  verified: boolean('verified').notNull().default(false),
+  jsonb: jsonb('jsonb').$type<string[]>(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+// New approach
+type SelectUser = typeof usersTable.$inferSelect;
+type InsertUser = typeof usersTable.$inferInsert;
+
+// Legacy approach (deprecated)
+type SelectUser2 = InferSelectModel<typeof usersTable>;
+type InsertUser2 = InferInsertModel<typeof usersTable>;
+```
+
+### Other Changes
+- Deprecated `InferModel` type in favor of `InferSelectModel` and `InferInsertModel`
+- Disabled `.d.ts` files bundling

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

@@ -0,0 +1,8 @@
+## v0.28.4 Release (2023-08-24)
+
+### Fixes
+- Fixed imports in ESM-based projects (issue #1088)
+- Fixed type error on Postgres table definitions (issue #1089)
+
+### Note
+If you encounter a `Cannot find package '@opentelemetry/api'` error, update to v0.28.5 where this is resolved.

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

@@ -0,0 +1,7 @@
+## v0.28.5 Release
+
+**Fix:** Corrected incorrect OpenTelemetry type import that caused a runtime error.
+
+**Details:** The issue was caused by using `import { type ... }` syntax instead of `import type { ... }` on the tracing.ts file, which caused the `import '@opentelemetry/api'` line to leak into runtime code.
+
+**Context:** OpenTelemetry integration in drizzle-orm is currently disabled and does nothing. It was an experimental feature designed to allow users to collect query statistics and send them to their own telemetry consumers. The ORM itself never collects or sends any stats. OpenTelemetry is simply a protocol that the library provides hooks for, but the feature is not active in current versions.

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

@@ -0,0 +1,54 @@
+## Changes
+MySQL `datetime` with `mode: 'date'` now stores and retrieves dates in UTC strings. Use `mode: 'string'` or custom types for different behavior.
+
+## New Features
+
+**LibSQL batch API support**
+Execute multiple queries in a single batch call:
+```ts
+const batchResponse = await db.batch([
+  db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+  db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)),
+  db.query.usersTable.findMany({}),
+  db.select().from(usersTable).where(eq(usersTable.id, 1)),
+]);
+// Returns: [{ id: number }[], ResultSet, User[], User[]]
+```
+Supported builders: `db.all()`, `db.get()`, `db.values()`, `db.run()`, `db.query.<table>.findMany()`, `db.query.<table>.findFirst()`, `db.select()...`, `db.update()...`, `db.delete()...`, `db.insert()...`
+
+**JSON mode for SQLite text columns**
+```ts
+const test = sqliteTable('test', {
+  dataTyped: text('data_typed', { mode: 'json' }).$type<{ a: 1 }>().notNull(),
+});
+```
+
+**`.toSQL()` on Relational Query API**
+```ts
+const query = db.query.usersTable.findFirst().toSQL();
+```
+
+**PostgreSQL array operators**
+```ts
+const contains = await db.select({ id: posts.id }).from(posts)
+  .where(arrayContains(posts.tags, ['Typescript', 'ORM']));
+const contained = await db.select({ id: posts.id }).from(posts)
+  .where(arrayContained(posts.tags, ['Typescript', 'ORM']));
+const overlaps = await db.select({ id: posts.id }).from(posts)
+  .where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']));
+const withSubQuery = await db.select({ id: posts.id }).from(posts)
+  .where(arrayContains(posts.tags, db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1))));
+```
+
+**More SQL operators in Relational Query where filters**
+```ts
+// Before: import { inArray } from "drizzle-orm/pg-core"; await db.users.findFirst({ where: (table, _) => inArray(table.id, [...]) })
+// After: await db.users.findFirst({ where: (table, { inArray }) => inArray(table.id, [...]) })
+```
+
+## Fixes
+- Correct where in on conflict in SQLite
+- Fix libsql/client type import
+- Fix raw SQL query mapping on RDS
+- Fix datetime mapping for MySQL
+- Fix smallserial generating as serial

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

@@ -0,0 +1,143 @@
+## MySQL unsigned bigint
+```ts
+const table = mysqlTable('table', {
+  id: bigint('id', { mode: 'number', unsigned: true }),
+});
+```
+
+## Improved query builder types
+By default, query builder methods can only be invoked once (e.g., `.where()` once per query) to match SQL semantics. Use `.$dynamic()` to enable multiple invocations for dynamic query building:
+
+```ts
+function withPagination<T extends PgSelect>(qb: T, page: number, pageSize: number = 10) {
+  return qb.limit(pageSize).offset(page * pageSize);
+}
+
+const query = db.select().from(users).where(eq(users.id, 1)).$dynamic();
+withPagination(query, 1); // ✅ OK
+
+function withFriends<T extends PgSelect>(qb: T) {
+  return qb.leftJoin(friends, eq(friends.userId, users.id));
+}
+query = withFriends(query);
+```
+
+## Custom names for primary and foreign keys
+```ts
+const table = pgTable('table', {
+  id: integer('id'),
+  name: text('name'),
+}, (table) => ({
+  cpk: primaryKey({ name: 'composite_key', columns: [table.id, table.name] }),
+  cfk: foreignKey({
+    name: 'fkName',
+    columns: [table.id],
+    foreignColumns: [table.name],
+  }),
+}));
+```
+
+## Read replicas support
+```ts
+const primaryDb = drizzle({ client });
+const read1 = drizzle({ client });
+const read2 = drizzle({ client });
+const db = withReplicas(primaryDb, [read1, read2]);
+
+db.$primary.select().from(usersTable); // read from primary
+db.select().from(usersTable); // read from replica
+db.delete(usersTable).where(eq(usersTable.id, 1)); // write to primary
+```
+
+Custom replica selection with weighted probability:
+```ts
+const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+  const weight = [0.7, 0.3];
+  let cumulativeProbability = 0;
+  const rand = Math.random();
+  for (const [i, replica] of replicas.entries()) {
+    cumulativeProbability += weight[i]!;
+    if (rand < cumulativeProbability) return replica;
+  }
+  return replicas[0]!
+});
+```
+
+## Set operators (UNION, UNION ALL, INTERSECT, INTERSECT ALL, EXCEPT, EXCEPT ALL)
+```ts
+// Import approach
+import { union } from 'drizzle-orm/pg-core'
+const result = await union(
+  db.select().from(users),
+  db.select().from(customers)
+);
+
+// Builder approach
+const result = await db.select().from(users).union(db.select().from(customers));
+```
+
+## MySQL proxy driver
+Implement HTTP endpoints for queries and migrations. Driver example:
+```ts
+import { drizzle } from 'drizzle-orm/mysql-proxy';
+import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
+
+const db = drizzle(async (sql, params, method) => {
+  const rows = await axios.post(`${process.env.REMOTE_DRIVER}/query`, { sql, params, method });
+  return { rows: rows.data };
+});
+
+await migrate(db, async (queries) => {
+  await axios.post(`${process.env.REMOTE_DRIVER}/migrate`, { queries });
+}, { migrationsFolder: 'drizzle' });
+
+await db.insert(cities).values({ id: 1, name: 'name' });
+```
+
+## PostgreSQL proxy driver
+Same as MySQL proxy driver:
+```ts
+import { drizzle } from 'drizzle-orm/pg-proxy';
+import { migrate } from 'drizzle-orm/pg-proxy/migrator';
+
+const db = drizzle(async (sql, params, method) => {
+  const rows = await axios.post(`${process.env.REMOTE_DRIVER}/query`, { sql, params, method });
+  return { rows: rows.data };
+});
+
+await migrate(db, async (queries) => {
+  await axios.post(`${process.env.REMOTE_DRIVER}/query`, { queries });
+}, { migrationsFolder: 'drizzle' });
+```
+
+## D1 Batch API support
+```ts
+const batchResponse = await db.batch([
+  db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+  db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)),
+  db.query.usersTable.findMany({}),
+  db.select().from(usersTable).where(eq(usersTable.id, 1)),
+  db.select({ id: usersTable.id, invitedBy: usersTable.invitedBy }).from(usersTable),
+]);
+
+type BatchResponse = [
+  { id: number }[],
+  D1Result,
+  { id: number; name: string; verified: number; invitedBy: number | null }[],
+  { id: number; name: string; verified: number; invitedBy: number | null }[],
+  { id: number; invitedBy: number | null }[],
+];
+```
+
+Supported builders: `db.all()`, `db.get()`, `db.values()`, `db.run()`, `db.query.<table>.findMany()`, `db.query.<table>.findFirst()`, `db.select()...`, `db.update()...`, `db.delete()...`, `db.insert()...`
+
+## Drizzle Kit 0.20.0
+- `defineConfig` function for config definition
+- Cloudflare D1 access in Drizzle Studio via wrangler.toml
+- Drizzle Studio migrated to https://local.drizzle.studio/
+- `bigint unsigned` support
+- Custom names for `primaryKeys` and `foreignKeys`
+- Automatic environment variable fetching
+- Bug fixes and improvements
+
+**Note:** v0.29.0 requires minimum Drizzle Kit v0.20.0 and vice versa.