npm - @lunarhue/expo-wa-sqlite - Versions diffs - 0.0.1 - Mend

@lunarhue/expo-wa-sqlite 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (224) hide show

package/.claude/settings.local.json ADDED Viewed

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx tsc:*)",
+      "Bash(pnpm add:*)",
+      "Bash(node:*)"
+    ]
+  }
+}

package/.lovely-docs.yaml ADDED Viewed

@@ -0,0 +1,11 @@
+source:
+  type: git
+  repo: https://github.com/xl0/lovely-docs
+  branch: master
+  gitCacheDir: /Users/wesleybaldwin/Library/Caches/lovely-docs/github.com/xl0/lovely-docs
+installed:
+  - drizzle-orm
+installs: digest
+summaries: true
+llms_map: false
+installDir: lovely-docs

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2026 Roy T. Hashimoto, LunarHUE LLC
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/demo/next.config.mjs ADDED Viewed

@@ -0,0 +1,17 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // Transpile workspace packages that ship TypeScript source
+  transpilePackages: ['@lunarhue/expo-wa-sqlite'],
+  webpack(config) {
+    // wa-sqlite-async.mjs is an Emscripten module — tell webpack not to
+    // parse it so it can fetch the WASM binary at runtime via locateFile.
+    config.module.rules.push({
+      test: /wa-sqlite-async\.mjs$/,
+      type: 'javascript/auto',
+    });
+    return config;
+  },
+};
+export default nextConfig;

package/demo/package.json ADDED Viewed

@@ -0,0 +1,26 @@
+{
+  "name": "@lunarhue/expo-wa-sqlite-demo",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "node scripts/copy-wasm.mjs && next dev",
+    "build": "node scripts/copy-wasm.mjs && next build",
+    "start": "next start"
+  },
+  "dependencies": {
+    "@lunarhue/expo-wa-sqlite": "workspace:*",
+    "@lunarhue/wa-sqlite": "workspace:*",
+    "@lunarhue/wa-sqlite-wasm": "workspace:*",
+    "drizzle-orm": "^0.43.1",
+    "next": "^15.2.3",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "typescript": "^5.3.3"
+  }
+}

package/demo/scripts/copy-wasm.mjs ADDED Viewed

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// Copies the wa-sqlite-async WASM binary into /public so Next.js can serve it.
+import { copyFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+const require = createRequire(import.meta.url);
+const wasmPkg = path.dirname(require.resolve('@lunarhue/wa-sqlite-wasm/wa-sqlite-async.mjs'));
+const src = path.join(wasmPkg, 'wa-sqlite-async.wasm');
+const dest = fileURLToPath(new URL('../public/wa-sqlite-async.wasm', import.meta.url));
+await copyFile(src, dest);
+console.log('Copied wa-sqlite-async.wasm → public/');

package/demo/src/app/layout.tsx ADDED Viewed

@@ -0,0 +1,16 @@
+import type { Metadata } from 'next';
+export const metadata: Metadata = {
+  title: 'wa-sqlite + Drizzle Demo',
+  description: 'IDBBatchAtomicVFS + drizzle-orm in the browser',
+};
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body style={{ fontFamily: 'system-ui, sans-serif', maxWidth: 640, margin: '3rem auto', padding: '0 1rem' }}>
+        {children}
+      </body>
+    </html>
+  );
+}

package/demo/src/app/page.tsx ADDED Viewed

@@ -0,0 +1,16 @@
+import { Suspense } from 'react';
+import Todos from './todos';
+export default function Page() {
+  return (
+    <>
+      <h1>wa-sqlite + Drizzle</h1>
+      <p style={{ color: '#555' }}>
+        Persisted in IndexedDB via <code>IDBBatchAtomicVFS</code>. Reload the page — your todos survive.
+      </p>
+      <Suspense fallback={<p>Initialising database…</p>}>
+        <Todos />
+      </Suspense>
+    </>
+  );
+}

package/demo/src/app/todos.tsx ADDED Viewed

@@ -0,0 +1,118 @@
+'use client';
+import { eq } from 'drizzle-orm';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useWaSQLiteDB } from '@lunarhue/expo-wa-sqlite';
+import { todos } from '@/db/schema';
+// The Emscripten module factory — imported at module scope so the singleton
+// in useWaSQLiteDB only ever sees one reference to it.
+// We use a dynamic import so Next.js doesn't try to SSR this module.
+const moduleFactoryPromise =
+  typeof window !== 'undefined'
+    ? import('@lunarhue/wa-sqlite-wasm/wa-sqlite-async.mjs').then((m) => m.default)
+    : Promise.resolve(null as any);
+type Todo = typeof todos.$inferSelect;
+export default function Todos() {
+  const [moduleFactory, setModuleFactory] = useState<((...args: any[]) => Promise<any>) | null>(null);
+  useEffect(() => {
+    moduleFactoryPromise.then(setModuleFactory);
+  }, []);
+  if (!moduleFactory) return <p>Loading WASM…</p>;
+  return <TodoApp moduleFactory={moduleFactory} />;
+}
+function TodoApp({ moduleFactory }: { moduleFactory: (...args: any[]) => Promise<any> }) {
+  const { db, isReady, error } = useWaSQLiteDB({
+    dbName: 'todos-demo',
+    moduleFactory,
+    // The WASM binary is copied to /public by the dev/build script.
+    wasmUrl: '/wa-sqlite-async.wasm',
+  });
+  const [items, setItems] = useState<Todo[]>([]);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const refresh = useCallback(async () => {
+    if (!db) return;
+    setItems(await db.select().from(todos).orderBy(todos.id));
+  }, [db]);
+  useEffect(() => {
+    if (isReady) refresh();
+  }, [isReady, refresh]);
+  const addTodo = async (e: React.FormEvent) => {
+    e.preventDefault();
+    const text = inputRef.current?.value.trim();
+    if (!text || !db) return;
+    await db.insert(todos).values({ text, done: false });
+    inputRef.current!.value = '';
+    refresh();
+  };
+  const toggleTodo = async (todo: Todo) => {
+    if (!db) return;
+    await db.update(todos).set({ done: !todo.done }).where(eq(todos.id, todo.id));
+    refresh();
+  };
+  const deleteTodo = async (id: number) => {
+    if (!db) return;
+    await db.delete(todos).where(eq(todos.id, id));
+    refresh();
+  };
+  if (error) {
+    return <p style={{ color: 'red' }}>Error: {error.message}</p>;
+  }
+  if (!isReady) {
+    return <p>Opening database…</p>;
+  }
+  return (
+    <div>
+      <form onSubmit={addTodo} style={{ display: 'flex', gap: 8, marginBottom: 16 }}>
+        <input
+          ref={inputRef}
+          placeholder="What needs doing?"
+          style={{ flex: 1, padding: '6px 10px', fontSize: 16 }}
+        />
+        <button type="submit" style={{ padding: '6px 16px' }}>Add</button>
+      </form>
+      {items.length === 0 && <p style={{ color: '#888' }}>No todos yet.</p>}
+      <ul style={{ listStyle: 'none', padding: 0 }}>
+        {items.map((todo) => (
+          <li
+            key={todo.id}
+            style={{ display: 'flex', alignItems: 'center', gap: 8, marginBottom: 8 }}
+          >
+            <input
+              type="checkbox"
+              checked={todo.done}
+              onChange={() => toggleTodo(todo)}
+            />
+            <span style={{ flex: 1, textDecoration: todo.done ? 'line-through' : 'none', color: todo.done ? '#aaa' : 'inherit' }}>
+              {todo.text}
+            </span>
+            <button onClick={() => deleteTodo(todo.id)} style={{ color: 'red', background: 'none', border: 'none', cursor: 'pointer' }}>
+              ✕
+            </button>
+          </li>
+        ))}
+      </ul>
+      <p style={{ marginTop: 24, fontSize: 12, color: '#aaa' }}>
+        Storage: IndexedDB · VFS: IDBBatchAtomicVFS · ORM: drizzle-orm
+      </p>
+    </div>
+  );
+}

package/demo/src/db/schema.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const todos = sqliteTable('todos', {
+  id: int().primaryKey({ autoIncrement: true }),
+  text: text().notNull(),
+  done: int({ mode: 'boolean' }).notNull().default(false),
+});

package/demo/tsconfig.json ADDED Viewed

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "preserve",
+    "strict": true,
+    "skipLibCheck": true,
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/lovely-docs/drizzle-orm/arktype.md ADDED Viewed

@@ -0,0 +1,113 @@
+## drizzle-arktype Plugin
+Plugin for Drizzle ORM that generates Arktype schemas from Drizzle ORM schemas. Requires Drizzle ORM v0.36.0+, Arktype v2.0.0+.
+### Select Schema
+Validates data queried from the database (API responses).
+```ts
+import { pgTable, text, integer } from 'drizzle-orm/pg-core';
+import { createSelectSchema } from 'drizzle-arktype';
+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(rows[0]); // validates all fields are present
+```
+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 into the database (API requests).
+```ts
+const userInsertSchema = createInsertSchema(users);
+const user = { name: 'Jane', age: 30 };
+const parsed = userInsertSchema(user); // validates required fields
+await db.insert(users).values(parsed);
+```
+### Update Schema
+Validates data to be updated in the database (API requests). Generated columns cannot be updated.
+```ts
+const userUpdateSchema = createUpdateSchema(users);
+const user = { age: 35 };
+const parsed = userUpdateSchema(user); // all fields optional, generated columns rejected
+await db.update(users).set(parsed).where(eq(users.name, 'Jane'));
+```
+### Refinements
+Each create schema function accepts optional refinements parameter to extend, modify, or overwrite field schemas:
+```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
+Boolean: `pg.boolean()`, `mysql.boolean()`, `sqlite.integer({ mode: 'boolean' })` → `type.boolean`
+Date: `pg.date({ mode: 'date' })`, `pg.timestamp({ mode: 'date' })`, `mysql.date({ mode: 'date' })`, `mysql.datetime({ mode: 'date' })`, `mysql.timestamp({ mode: 'date' })`, `sqlite.integer({ mode: 'timestamp' })`, `sqlite.integer({ mode: 'timestamp_ms' })` → `type.Date`
+String: `pg.date({ mode: 'string' })`, `pg.timestamp({ mode: 'string' })`, `pg.cidr()`, `pg.inet()`, `pg.interval()`, `pg.macaddr()`, `pg.macaddr8()`, `pg.numeric()`, `pg.text()`, `pg.sparsevec()`, `pg.time()`, `mysql.binary()`, `mysql.date({ mode: 'string' })`, `mysql.datetime({ mode: 'string' })`, `mysql.decimal()`, `mysql.time()`, `mysql.timestamp({ mode: 'string' })`, `mysql.varbinary()`, `sqlite.numeric()`, `sqlite.text({ mode: 'text' })` → `type.string`
+Bit: `pg.bit({ dimensions: ... })` → `type(/^[01]{${column.dimensions}}$/)`
+UUID: `pg.uuid()` → `type(/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu)`
+Char: `pg.char({ length: ... })`, `mysql.char({ length: ... })` → `type.string.exactlyLength(length)`
+Varchar: `pg.varchar({ length: ... })`, `mysql.varchar({ length: ... })`, `sqlite.text({ mode: 'text', length: ... })` → `type.string.atMostLength(length)`
+MySQL text variants: `mysql.tinytext()` → `type.string.atMostLength(255)`, `mysql.text()` → `type.string.atMostLength(65_535)`, `mysql.mediumtext()` → `type.string.atMostLength(16_777_215)`, `mysql.longtext()` → `type.string.atMostLength(4_294_967_295)`
+Enum: `pg.text({ enum: ... })`, `pg.char({ enum: ... })`, `pg.varchar({ enum: ... })`, `mysql.tinytext({ enum: ... })`, `mysql.mediumtext({ enum: ... })`, `mysql.text({ enum: ... })`, `mysql.longtext({ enum: ... })`, `mysql.char({ enum: ... })`, `mysql.varchar({ enum: ... })`, `mysql.mysqlEnum(...)`, `sqlite.text({ mode: 'text', enum: ... })` → `type.enumerated(...enum)`
+Integer types with ranges:
+- `mysql.tinyint()` → `type.keywords.number.integer.atLeast(-128).atMost(127)`
+- `mysql.tinyint({ unsigned: true })` → `type.keywords.number.integer.atLeast(0).atMost(255)`
+- `pg.smallint()`, `pg.smallserial()`, `mysql.smallint()` → `type.keywords.number.integer.atLeast(-32_768).atMost(32_767)`
+- `mysql.smallint({ unsigned: true })` → `type.keywords.number.integer.atLeast(0).atMost(65_535)`
+- `pg.real()`, `mysql.float()` → `type.number.atLeast(-8_388_608).atMost(8_388_607)`
+- `mysql.mediumint()` → `type.keywords.number.integer.atLeast(-8_388_608).atMost(8_388_607)`
+- `mysql.float({ unsigned: true })` → `type.number.atLeast(0).atMost(16_777_215)`
+- `mysql.mediumint({ unsigned: true })` → `type.keywords.number.integer.atLeast(0).atMost(16_777_215)`
+- `pg.integer()`, `pg.serial()`, `mysql.int()` → `type.keywords.number.integer.atLeast(-2_147_483_648).atMost(2_147_483_647)`
+- `mysql.int({ unsigned: true })` → `type.keywords.number.integer.atLeast(0).atMost(4_294_967_295)`
+- `pg.doublePrecision()`, `mysql.double()`, `mysql.real()`, `sqlite.real()` → `type.number.atLeast(-140_737_488_355_328).atMost(140_737_488_355_327)`
+- `mysql.double({ unsigned: true })` → `type.number.atLeast(0).atMost(281_474_976_710_655)`
+- `pg.bigint({ mode: 'number' })`, `pg.bigserial({ mode: 'number' })`, `mysql.bigint({ mode: 'number' })`, `mysql.bigserial({ mode: 'number' })`, `sqlite.integer({ mode: 'number' })` → `type.keywords.number.integer.atLeast(-9_007_199_254_740_991).atMost(9_007_199_254_740_991)`
+- `mysql.serial()` → `type.keywords.number.integer.atLeast(0).atMost(9_007_199_254_740_991)`
+- `pg.bigint({ mode: 'bigint' })`, `pg.bigserial({ mode: 'bigint' })`, `mysql.bigint({ mode: 'bigint' })`, `sqlite.blob({ mode: 'bigint' })` → `type.bigint.narrow(...)` with 64-bit limits
+- `mysql.bigint({ mode: 'bigint', unsigned: true })` → `type.bigint.narrow(...)` with unsigned 64-bit limits
+Year: `mysql.year()` → `type.keywords.number.integer.atLeast(1_901).atMost(2_155)`
+Geometry point: `pg.geometry({ type: 'point', mode: 'tuple' })`, `pg.point({ mode: 'tuple' })` → `type([type.number, type.number])` or `pg.geometry({ type: 'point', mode: 'xy' })`, `pg.point({ mode: 'xy' })` → `type({ x: type.number, y: type.number })`
+Vectors: `pg.halfvec({ dimensions: ... })`, `pg.vector({ dimensions: ... })` → `type.number.array().exactlyLength(dimensions)`
+Line: `pg.line({ mode: 'abc' })` → `type({ a: type.number, b: type.number, c: type.number })` or `pg.line({ mode: 'tuple' })` → `type([type.number, type.number, type.number])`
+JSON: `pg.json()`, `pg.jsonb()`, `mysql.json()`, `sqlite.blob({ mode: 'json' })`, `sqlite.text({ mode: 'json' })` → `type('string | number | boolean | null').or(type('unknown.any[] | Record<string, unknown.any>'))`
+Buffer: `sqlite.blob({ mode: 'buffer' })` → `type.instanceOf(Buffer)`
+Arrays: `pg.dataType().array(...)` → `baseDataTypeSchema.array().exactlyLength(size)`

package/lovely-docs/drizzle-orm/batch-api.md ADDED Viewed

@@ -0,0 +1,35 @@
+## Batch API
+Execute multiple SQL statements in a single database call with implicit transaction handling.
+### Overview
+Batch APIs are supported for LibSQL, Neon, and D1 drivers. A batch executes one or more SQL statements in order within an implicit transaction. If all statements succeed, the transaction commits. If any statement fails, the entire transaction rolls back.
+**LibSQL**: Batch is an implicit transaction controlled by the backend.
+**D1**: Batching reduces network latency by sending multiple statements in one call. Operates in auto-commit mode. Statements execute sequentially and non-concurrently. If any statement fails, the sequence aborts and rolls back.
+### Usage
+```ts
+const batchResponse: 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),
+]);
+```
+The response is a tuple where each element corresponds to the result of each statement in the batch. Return types vary by driver:
+- **libSQL**: `ResultSet` for mutations
+- **Neon**: `NeonHttpQueryResult` for mutations
+- **D1**: `D1Result` for mutations
+### Supported Builders
+All query builders can be used in `db.batch()`:
+- `db.all()`, `db.get()`, `db.values()`, `db.run()`, `db.execute()`
+- `db.query.<table>.findMany()`, `db.query.<table>.findFirst()`
+- `db.select()`, `db.update()`, `db.delete()`, `db.insert()`

package/lovely-docs/drizzle-orm/cache.md ADDED Viewed

@@ -0,0 +1,145 @@
+## Overview
+Drizzle sends every query to the database by default with no automatic caching. Caching is opt-in using an `explicit` strategy (`global: false`) by default, or can be enabled globally with `global: true`.
+## Upstash Integration
+Quick setup with automatic environment variable configuration:
+```ts
+import { upstashCache } from "drizzle-orm/cache/upstash";
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache() });
+```
+With explicit credentials and options:
+```ts
+const db = drizzle(process.env.DB_URL!, {
+  cache: upstashCache({
+    url: '<UPSTASH_URL>',
+    token: '<UPSTASH_TOKEN>',
+    global: true,  // cache all queries by default
+    config: { ex: 60 }  // 60 second TTL
+  })
+});
+```
+## Cache Config
+```ts
+type CacheConfig = {
+  ex?: number;  // expiration in seconds
+  hexOptions?: "NX" | "nx" | "XX" | "xx" | "GT" | "gt" | "LT" | "lt";  // HEXPIRE options
+};
+```
+## Usage Examples
+**With `global: false` (default, opt-in):**
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache({ url: "", token: "" }) });
+// Won't use cache
+const res = await db.select().from(users);
+// Use cache with .$withCache()
+const res = await db.select().from(users).$withCache();
+// Options for .$withCache()
+.$withCache({ config: { ex: 60 } })  // custom TTL
+.$withCache({ tag: 'custom_key' })  // custom cache key
+.$withCache({ autoInvalidate: false })  // disable auto-invalidation for eventual consistency
+// Mutations still trigger cache invalidation
+await db.insert(users).value({ email: "test@example.com" });
+```
+**With `global: true`:**
+```ts
+const db = drizzle(process.env.DB_URL!, { cache: upstashCache({ url: "", token: "", global: true }) });
+// All queries use cache by default
+const res = await db.select().from(users);
+// Disable cache for specific query
+const res = await db.select().from(users).$withCache(false);
+// Manual invalidation
+await db.$cache.invalidate({ tables: users });
+await db.$cache.invalidate({ tables: [users, posts] });
+await db.$cache.invalidate({ tables: "usersTable" });
+await db.$cache.invalidate({ tags: "custom_key" });
+```
+## Custom Cache Implementation
+Extend the `Cache` class with `strategy()`, `get()`, `put()`, and `onMutate()` methods:
+```ts
+import Keyv from "keyv";
+export class TestGlobalCache extends Cache {
+  private globalTtl: number = 1000;
+  private usedTablesPerKey: Record<string, string[]> = {};
+  constructor(private kv: Keyv = new Keyv()) {
+    super();
+  }
+  override strategy(): "explicit" | "all" {
+    return "all";  // or "explicit"
+  }
+  override async get(key: string): Promise<any[] | undefined> {
+    return (await this.kv.get(key)) ?? undefined;
+  }
+  override async put(
+    key: string,
+    response: any,
+    tables: string[],
+    config?: CacheConfig,
+  ): Promise<void> {
+    const ttl = config?.px ?? (config?.ex ? config.ex * 1000 : this.globalTtl);
+    await this.kv.set(key, response, ttl);
+    for (const table of tables) {
+      const keys = this.usedTablesPerKey[table];
+      if (keys === undefined) {
+        this.usedTablesPerKey[table] = [key];
+      } else {
+        keys.push(key);
+      }
+    }
+  }
+  override async onMutate(params: {
+    tags: string | string[];
+    tables: string | string[] | Table<any> | Table<any>[];
+  }): Promise<void> {
+    const tagsArray = Array.isArray(params.tags) ? params.tags : params.tags ? [params.tags] : [];
+    const tablesArray = Array.isArray(params.tables) ? params.tables : params.tables ? [params.tables] : [];
+    const keysToDelete = new Set<string>();
+    for (const table of tablesArray) {
+      const tableName = is(table, Table) ? getTableName(table) : (table as string);
+      const keys = this.usedTablesPerKey[tableName] ?? [];
+      for (const key of keys) keysToDelete.add(key);
+    }
+    for (const tag of tagsArray) {
+      await this.kv.delete(tag);
+    }
+    for (const key of keysToDelete) {
+      await this.kv.delete(key);
+    }
+  }
+}
+const db = drizzle(process.env.DB_URL!, { cache: new TestGlobalCache() });
+```
+## Limitations
+**Not supported:**
+- Raw queries: `db.execute(sql\`select 1\`)`
+- Batch operations in d1 and libsql
+- Transactions
+- Relational queries: `db.query.users.findMany()`
+- better-sqlite3, Durable Objects, expo sqlite
+- AWS Data API drivers
+- Views

package/lovely-docs/drizzle-orm/check-migrations.md ADDED Viewed

@@ -0,0 +1,52 @@
+## Purpose
+`drizzle-kit check` validates consistency of generated SQL migrations history. Essential for teams with multiple developers working on different branches altering the database schema.
+## Configuration
+Requires `dialect` and database connection credentials via `drizzle.config.ts` or CLI options.
+**With config file:**
+```ts
+// drizzle.config.ts
+import { defineConfig } from "drizzle-kit";
+export default defineConfig({
+  dialect: "postgresql",
+});
+```
+```shell
+npx drizzle-kit check
+```
+**As CLI options:**
+```shell
+npx drizzle-kit check --dialect=postgresql
+```
+## Multiple Configuration Files
+Support for multiple config files in one project for different database stages:
+```plaintext
+📦 <project root>
+ ├ 📂 drizzle
+ ├ 📂 src
+ ├ 📜 .env
+ ├ 📜 drizzle-dev.config.ts
+ ├ 📜 drizzle-prod.config.ts
+ ├ 📜 package.json
+ └ 📜 tsconfig.json
+```
+```shell
+npx drizzle-kit check --config=drizzle-dev.config.ts
+npx drizzle-kit check --config=drizzle-prod.config.ts
+```
+## CLI Options
+| Option | Required | Description |
+|--------|----------|-------------|
+| `dialect` | yes | Database dialect: `postgresql`, `mysql`, or `sqlite` |
+| `out` | no | Migrations folder, default: `./drizzle` |
+| `config` | no | Config file path, default: `drizzle.config.ts` |
+**Examples:**
+```shell
+npx drizzle-kit check --dialect=postgresql
+npx drizzle-kit check --dialect=postgresql --out=./migrations-folder
+```