zod-sqlite 1.0.2 → 1.0.4

package/README.md

@@ -1,6 +1,15 @@
-# Zod-SQLite
-
-Generate type-safe SQLite table schemas from Zod validation schemas. Define your database structure once using Zod, and automatically generate both SQL CREATE TABLE statements and runtime validation schemas with full TypeScript type inference.
+<div align="center">
+  <h1>Zod-SQLite</h1>
+  <p><strong>Generate type-safe SQLite table schemas from Zod validation schemas. Define your database structure once using Zod, and automatically generate both SQL CREATE TABLE statements and runtime validation schemas with full TypeScript type inference.</strong></p>
+  <p>
+    <a href="https://github.com/favorodera/zod-sqlite/blob/main/LICENSE"><img src="https://img.shields.io/github/license/favorodera/zod-sqlite.svg?style=plastic&label=License&color=blue" alt="License"></a>
+    <a href="https://github.com/favorodera/zod-sqlite/stargazers"><img src="https://img.shields.io/github/stars/favorodera/zod-sqlite.svg?style=plastic&label=Stars&color=blue" alt="GitHub Stars"></a>
+    <a href="https://npmx.dev/package/zod-sqlite"><img src="https://img.shields.io/npm/dt/zod-sqlite.svg?style=plastic&label=NPM%20Downloads&color=blue" alt="NPM Downloads"></a>
+    <a href="https://npmx.dev/package/zod-sqlite"><img src="https://img.shields.io/npm/v/zod-sqlite.svg?style=plastic&label=Version&color=blue" alt="NPM Version"></a>
+  </p>
+</div>
+
+<br>
 
 ## Table of Contents
 
@@ -44,57 +53,50 @@ This tool bridges the gap between Zod schemas and SQLite database definitions. I
 npm install zod-sqlite
 ```
 
-Requires Zod v4 as a peer dependency:
-
-```bash
-npm install zod
-```
-
 ## Quick Start
 
 Here's a simple example creating a users table:
 
 ```typescript
-import { createTable } from 'zod-sqlite'
-import { z } from 'zod'
-
-const users = createTable({
-  name: 'users',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'email', schema: z.email() },
-    { name: 'username', schema: z.string().min(3).max(20) },
-    { name: 'created_at', schema: z.date().default(new Date()) }
-  ],
-  primaryKeys: ['id'],
-  indexes: [
-    { name: 'idx_users_email', columns: ['email'], unique: true }
-  ]
-})
-
-// Use the generated SQL
-console.log(users.table)
-// CREATE TABLE users (
-//   id INTEGER NOT NULL,
-//   email TEXT NOT NULL,
-//   username TEXT NOT NULL CHECK(length(username) >= 3 AND length(username) <= 20),
-//   created_at DATE NOT NULL DEFAULT '2026-01-06T...',
-//   PRIMARY KEY (id)
-// );
-
-console.log(users.indexes[0])
-// CREATE UNIQUE INDEX idx_users_email ON users (email);
-
-// Validate data at runtime
-const result = users.schema.safeParse({
-  id: 1,
-  email: 'user@example.com',
-  username: 'john',
-  created_at: new Date()
-})
-
-// TypeScript type inference
-type User = z.infer<typeof users.schema>
+import { z } from 'zod'
+import { createTable } from 'zod-sqlite'
+
+const users = createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'email', schema: z.email() },
+    { name: 'username', schema: z.string().min(3)
+      .max(20) },
+    { name: 'created_at', schema: z.date().default(new Date()) },
+  ],
+  indexes: [{ columns: ['email'], name: 'idx_users_email', unique: true }],
+  name: 'users',
+  primaryKeys: ['id'],
+})
+
+// Use the generated SQL
+console.log(users.table)
+// CREATE TABLE users (
+//   id INTEGER NOT NULL,
+//   email TEXT NOT NULL,
+//   username TEXT NOT NULL CHECK(length(username) >= 3 AND length(username) <= 20),
+//   created_at DATE NOT NULL DEFAULT '2026-01-06T...',
+//   PRIMARY KEY (id)
+// );
+
+console.log(users.indexes[0])
+// CREATE UNIQUE INDEX idx_users_email ON users (email);
+
+// Validate data at runtime
+const result = users.schema.safeParse({
+  created_at: new Date(),
+  email: 'user@example.com',
+  id: 1,
+  username: 'john',
+})
+
+// TypeScript type inference
+type User = z.infer<typeof users.schema>
 // { id: number; email: string; username: string; created_at: Date }
 ```
 
@@ -112,7 +114,7 @@ Zod schemas serve as the source of truth for your database structure. Each colum
 `createTable` is the primary entry point. It accepts a configuration object and returns three things:
 
 ```typescript
-const result = createTable(config)
+const result = createTable(config)
 // Returns: { table: string, indexes: string[], schema: ZodObject }
 ```
 
@@ -140,7 +142,7 @@ Creates a table definition with SQL statements and validation schema.
 
 **Returns:**
 
-```typescript
+```plaintext
 {
   table: string        // CREATE TABLE SQL statement
   indexes: string[]    // Array of CREATE INDEX statements
@@ -151,14 +153,14 @@ Creates a table definition with SQL statements and validation schema.
 **Example:**
 
 ```typescript
-const { table, indexes, schema } = createTable({
-  name: 'products',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'name', schema: z.string() },
-    { name: 'price', schema: z.number().min(0) }
-  ],
-  primaryKeys: ['id']
+const { indexes, schema, table } = createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'name', schema: z.string() },
+    { name: 'price', schema: z.number().min(0) },
+  ],
+  name: 'products',
+  primaryKeys: ['id'],
 })
 ```
 
@@ -167,11 +169,11 @@ const { table, indexes, schema } = createTable({
 Configuration object for table creation.
 
 ```typescript
-type TableConfig = {
-  name: string                    // Table name
-  columns: ColumnConfig[]         // Array of column definitions
-  primaryKeys: string[]           // Column names forming primary key
-  indexes?: IndexConfig[]         // Optional index configurations
+interface TableConfig {
+  columns: Array<ColumnConfig> // Array of column definitions
+  indexes?: Array<IndexConfig> // Optional index configurations
+  name: string // Table name
+  primaryKeys: Array<string> // Column names forming primary key
 }
 ```
 
@@ -180,11 +182,11 @@ type TableConfig = {
 Configuration for a single column.
 
 ```typescript
-type ColumnConfig = {
-  name: string                    // Column name
-  schema: ZodType                 // Zod schema defining type and validation
-  unique?: boolean                // Whether values must be unique
-  references?: ForeignKeyReference // Foreign key configuration
+interface ColumnConfig {
+  name: string // Column name
+  references?: ForeignKeyReference // Foreign key configuration
+  schema: ZodType // Zod schema defining type and validation
+  unique?: boolean // Whether values must be unique
 }
 ```
 
@@ -193,19 +195,19 @@ type ColumnConfig = {
 Foreign key constraint configuration.
 
 ```typescript
-type ForeignKeyReference = {
-  table: string                   // Referenced table name
-  column: string                  // Referenced column name
-  onDelete?: ForeignKeyAction     // Action on parent deletion
-  onUpdate?: ForeignKeyAction     // Action on parent update
-}
-
-type ForeignKeyAction = 
-  | 'NO ACTION'
-  | 'RESTRICT' 
-  | 'SET NULL'
-  | 'SET DEFAULT'
-  | 'CASCADE'
+interface ForeignKeyReference {
+  column: string // Referenced column name
+  onDelete?: ForeignKeyAction // Action on parent deletion
+  onUpdate?: ForeignKeyAction // Action on parent update
+  table: string // Referenced table name
+}
+
+type ForeignKeyAction
+  = | 'CASCADE'
+    | 'NO ACTION'
+    | 'RESTRICT'
+    | 'SET DEFAULT'
+    | 'SET NULL'
 ```
 
 ### IndexConfig
@@ -213,11 +215,11 @@ type ForeignKeyAction =
 Index configuration for query optimization.
 
 ```typescript
-type IndexConfig = {
-  name: string          // Index name
-  columns: string[]     // Indexed column names
-  unique?: boolean      // Whether this is a unique index
-  where?: string        // Optional WHERE clause for partial index
+interface IndexConfig {
+  columns: Array<string> // Indexed column names
+  name: string // Index name
+  unique?: boolean // Whether this is a unique index
+  where?: string // Optional WHERE clause for partial index
 }
 ```
 
@@ -269,23 +271,24 @@ These Zod wrappers are automatically unwrapped:
 - `.default(value)` - Adds DEFAULT clause
 
 ```typescript
-z.string().optional()           // TEXT (nullable)
-z.number().default(0)           // REAL NOT NULL DEFAULT 0
-z.string().nullable().default('n/a') // TEXT DEFAULT 'n/a'
+z.string().optional() // TEXT (nullable)
+z.number().default(0) // REAL NOT NULL DEFAULT 0
+z.string().nullable()
+  .default('n/a') // TEXT DEFAULT 'n/a'
 ```
 
 ## Column Configuration
 
 ### Basic Columns
 
-```typescript
+```plaintext
 { name: 'email', schema: z.email() }
 // SQL: email TEXT NOT NULL
 ```
 
 ### Optional and Nullable Columns
 
-```typescript
+```plaintext
 { name: 'bio', schema: z.string().optional() }
 // SQL: bio TEXT
 
@@ -295,7 +298,7 @@ z.string().nullable().default('n/a') // TEXT DEFAULT 'n/a'
 
 ### Columns with Default Values
 
-```typescript
+```plaintext
 { name: 'status', schema: z.enum(['active', 'inactive']).default('active') }
 // SQL: status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'inactive'))
 
@@ -305,7 +308,7 @@ z.string().nullable().default('n/a') // TEXT DEFAULT 'n/a'
 
 ### Unique Columns
 
-```typescript
+```plaintext
 { name: 'username', schema: z.string(), unique: true }
 // SQL: username TEXT NOT NULL UNIQUE
 ```
@@ -316,7 +319,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### Enum Constraints
 
-```typescript
+```plaintext
 { 
   name: 'role', 
   schema: z.enum(['admin', 'user', 'guest']) 
@@ -326,7 +329,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### Literal Constraints
 
-```typescript
+```plaintext
 { 
   name: 'type', 
   schema: z.literal('premium') 
@@ -346,7 +349,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### Numeric Range Constraints
 
-```typescript
+```plaintext
 { 
   name: 'age', 
   schema: z.int().min(18).max(120) 
@@ -362,7 +365,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### String Length Constraints
 
-```typescript
+```plaintext
 { 
   name: 'username', 
   schema: z.string().min(3).max(20) 
@@ -383,14 +386,14 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 The most common pattern for entity tables:
 
 ```typescript
-createTable({
-  name: 'users',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'email', schema: z.string() }
-  ],
-  primaryKeys: ['id']
-})
+createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'email', schema: z.string() },
+  ],
+  name: 'users',
+  primaryKeys: ['id'],
+})
 // SQL: PRIMARY KEY (id)
 ```
 
@@ -399,29 +402,35 @@ createTable({
 Used for junction tables and multi-tenant data:
 
 ```typescript
-createTable({
-  name: 'user_roles',
-  columns: [
-    { name: 'user_id', schema: z.int() },
-    { name: 'role_id', schema: z.int() }
-  ],
-  primaryKeys: ['user_id', 'role_id']
-})
+createTable({
+  columns: [
+    { name: 'user_id', schema: z.int() },
+    { name: 'role_id', schema: z.int() },
+  ],
+  name: 'user_roles',
+  primaryKeys: [
+    'user_id',
+    'role_id',
+  ],
+})
 // SQL: PRIMARY KEY (user_id, role_id)
 ```
 
 ### Multi-Tenant Example
 
 ```typescript
-createTable({
-  name: 'documents',
-  columns: [
-    { name: 'tenant_id', schema: z.string() },
-    { name: 'doc_id', schema: z.int() },
-    { name: 'title', schema: z.string() }
-  ],
-  primaryKeys: ['tenant_id', 'doc_id']
-})
+createTable({
+  columns: [
+    { name: 'tenant_id', schema: z.string() },
+    { name: 'doc_id', schema: z.int() },
+    { name: 'title', schema: z.string() },
+  ],
+  name: 'documents',
+  primaryKeys: [
+    'tenant_id',
+    'doc_id',
+  ],
+})
 // SQL: PRIMARY KEY (tenant_id, doc_id)
 ```
 
@@ -430,21 +439,21 @@ createTable({
 ### Basic Foreign Key
 
 ```typescript
-createTable({
-  name: 'posts',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { 
-      name: 'author_id', 
-      schema: z.int(),
-      references: {
-        table: 'users',
-        column: 'id'
-      }
-    }
-  ],
-  primaryKeys: ['id']
-})
+createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    {
+      name: 'author_id',
+      references: {
+        column: 'id',
+        table: 'users',
+      },
+      schema: z.int(),
+    },
+  ],
+  name: 'posts',
+  primaryKeys: ['id'],
+})
 // SQL: author_id INTEGER NOT NULL REFERENCES users(id)
 ```
 
@@ -452,7 +461,7 @@ createTable({
 
 Automatically delete child records when parent is deleted:
 
-```typescript
+```plaintext
 {
   name: 'user_id',
   schema: z.int(),
@@ -469,7 +478,7 @@ Automatically delete child records when parent is deleted:
 
 Prevent deletion of parent if children exist:
 
-```typescript
+```plaintext
 {
   name: 'category_id',
   schema: z.int(),
@@ -486,7 +495,7 @@ Prevent deletion of parent if children exist:
 
 Set foreign key to NULL when parent is deleted:
 
-```typescript
+```plaintext
 {
   name: 'manager_id',
   schema: z.int().nullable(),
@@ -503,7 +512,7 @@ Set foreign key to NULL when parent is deleted:
 
 Propagate updates to child records:
 
-```typescript
+```plaintext
 {
   name: 'parent_id',
   schema: z.int(),
@@ -521,12 +530,12 @@ Propagate updates to child records:
 
 ### Simple Index
 
-```typescript
+```plaintext
 indexes: [
-  { 
-    name: 'idx_users_email', 
-    columns: ['email'] 
-  }
+  {
+    columns: ['email'],
+    name: 'idx_users_email',
+  },
 ]
 // SQL: CREATE INDEX idx_users_email ON users (email);
 ```
@@ -536,13 +545,13 @@ indexes: [
 Enforce uniqueness at the database level:
 
 ```typescript
-indexes: [
-  { 
-    name: 'idx_users_username', 
-    columns: ['username'], 
-    unique: true 
-  }
-]
+indexes: [
+  {
+    columns: ['username'],
+    name: 'idx_users_username',
+    unique: true,
+  },
+]
 // SQL: CREATE UNIQUE INDEX idx_users_username ON users (username);
 ```
 
@@ -551,12 +560,15 @@ indexes: [
 Index multiple columns together for multi-column queries:
 
 ```typescript
-indexes: [
-  { 
-    name: 'idx_posts_author_date', 
-    columns: ['author_id', 'created_at'] 
-  }
-]
+indexes: [
+  {
+    columns: [
+      'author_id',
+      'created_at',
+    ],
+    name: 'idx_posts_author_date',
+  },
+]
 // SQL: CREATE INDEX idx_posts_author_date ON posts (author_id, created_at);
 ```
 
@@ -571,13 +583,13 @@ SELECT * FROM posts WHERE author_id = 123 AND created_at > '2024-01-01';
 Index only rows matching a condition:
 
 ```typescript
-indexes: [
-  { 
-    name: 'idx_active_users', 
-    columns: ['last_login'],
-    where: 'deleted_at IS NULL'
-  }
-]
+indexes: [
+  {
+    columns: ['last_login'],
+    name: 'idx_active_users',
+    where: 'deleted_at IS NULL',
+  },
+]
 // SQL: CREATE INDEX idx_active_users ON posts (last_login) WHERE deleted_at IS NULL;
 ```
 
@@ -591,142 +603,160 @@ Benefits:
 ### Complete Blog Example
 
 ```typescript
-// Users table
-const users = createTable({
-  name: 'users',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'email', schema: z.email(), unique: true },
-    { name: 'username', schema: z.string().min(3).max(20), unique: true },
-    { name: 'role', schema: z.enum(['admin', 'author', 'reader']).default('reader') },
-    { name: 'created_at', schema: z.date().default(new Date()) }
-  ],
-  primaryKeys: ['id'],
-  indexes: [
-    { name: 'idx_users_email', columns: ['email'], unique: true },
-    { name: 'idx_users_role', columns: ['role'] }
-  ]
-})
-
-// Posts table with foreign key
-const posts = createTable({
-  name: 'posts',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'title', schema: z.string().min(1).max(200) },
-    { name: 'content', schema: z.string() },
-    { name: 'status', schema: z.enum(['draft', 'published', 'archived']).default('draft') },
-    { 
-      name: 'author_id', 
-      schema: z.int(),
-      references: {
-        table: 'users',
-        column: 'id',
-        onDelete: 'CASCADE'
-      }
-    },
-    { name: 'published_at', schema: z.date().nullable() },
-    { name: 'created_at', schema: z.date().default(new Date()) }
-  ],
-  primaryKeys: ['id'],
-  indexes: [
-    { name: 'idx_posts_author', columns: ['author_id'] },
-    { 
-      name: 'idx_posts_published', 
-      columns: ['published_at'],
-      where: "status = 'published'"
-    },
-    { name: 'idx_posts_status_date', columns: ['status', 'created_at'] }
-  ]
-})
-
-// Junction table for tags (many-to-many)
-const postTags = createTable({
-  name: 'post_tags',
-  columns: [
-    { 
-      name: 'post_id', 
-      schema: z.int(),
-      references: {
-        table: 'posts',
-        column: 'id',
-        onDelete: 'CASCADE'
-      }
-    },
-    { 
-      name: 'tag_id', 
-      schema: z.int(),
-      references: {
-        table: 'tags',
-        column: 'id',
-        onDelete: 'CASCADE'
-      }
-    },
-    { name: 'created_at', schema: z.date().default(new Date()) }
-  ],
-  primaryKeys: ['post_id', 'tag_id']
+// Users table
+const users = createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'email', schema: z.email(), unique: true },
+    { name: 'username', schema: z.string().min(3)
+      .max(20), unique: true },
+    { name: 'role', schema: z.enum([
+      'admin',
+      'author',
+      'reader',
+    ]).default('reader') },
+    { name: 'created_at', schema: z.date().default(new Date()) },
+  ],
+  indexes: [
+    { columns: ['email'], name: 'idx_users_email', unique: true },
+    { columns: ['role'], name: 'idx_users_role' },
+  ],
+  name: 'users',
+  primaryKeys: ['id'],
+})
+
+// Posts table with foreign key
+const posts = createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'title', schema: z.string().min(1)
+      .max(200) },
+    { name: 'content', schema: z.string() },
+    { name: 'status', schema: z.enum([
+      'draft',
+      'published',
+      'archived',
+    ]).default('draft') },
+    {
+      name: 'author_id',
+      references: {
+        column: 'id',
+        onDelete: 'CASCADE',
+        table: 'users',
+      },
+      schema: z.int(),
+    },
+    { name: 'published_at', schema: z.date().nullable() },
+    { name: 'created_at', schema: z.date().default(new Date()) },
+  ],
+  indexes: [
+    { columns: ['author_id'], name: 'idx_posts_author' },
+    {
+      columns: ['published_at'],
+      name: 'idx_posts_published',
+      where: 'status = \'published\'',
+    },
+    { columns: [
+      'status',
+      'created_at',
+    ], name: 'idx_posts_status_date' },
+  ],
+  name: 'posts',
+  primaryKeys: ['id'],
+})
+
+// Junction table for tags (many-to-many)
+const postTags = createTable({
+  columns: [
+    {
+      name: 'post_id',
+      references: {
+        column: 'id',
+        onDelete: 'CASCADE',
+        table: 'posts',
+      },
+      schema: z.int(),
+    },
+    {
+      name: 'tag_id',
+      references: {
+        column: 'id',
+        onDelete: 'CASCADE',
+        table: 'tags',
+      },
+      schema: z.int(),
+    },
+    { name: 'created_at', schema: z.date().default(new Date()) },
+  ],
+  name: 'post_tags',
+  primaryKeys: [
+    'post_id',
+    'tag_id',
+  ],
 })
 ```
 
 ### E-commerce Example
 
 ```typescript
-const products = createTable({
-  name: 'products',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'sku', schema: z.string().length(10), unique: true },
-    { name: 'name', schema: z.string().min(1) },
-    { name: 'description', schema: z.string().optional() },
-    { name: 'price', schema: z.number().min(0) },
-    { name: 'stock', schema: z.int().min(0).default(0) },
-    { name: 'active', schema: z.boolean().default(true) },
-    { 
-      name: 'category_id', 
-      schema: z.int(),
-      references: {
-        table: 'categories',
-        column: 'id',
-        onDelete: 'RESTRICT'
-      }
-    }
-  ],
-  primaryKeys: ['id'],
-  indexes: [
-    { name: 'idx_products_sku', columns: ['sku'], unique: true },
-    { name: 'idx_products_category', columns: ['category_id'] },
-    { 
-      name: 'idx_products_active', 
-      columns: ['price', 'stock'],
-      where: 'active = 1'
-    }
-  ]
+const products = createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'sku', schema: z.string().length(10), unique: true },
+    { name: 'name', schema: z.string().min(1) },
+    { name: 'description', schema: z.string().optional() },
+    { name: 'price', schema: z.number().min(0) },
+    { name: 'stock', schema: z.int().min(0)
+      .default(0) },
+    { name: 'active', schema: z.boolean().default(true) },
+    {
+      name: 'category_id',
+      references: {
+        column: 'id',
+        onDelete: 'RESTRICT',
+        table: 'categories',
+      },
+      schema: z.int(),
+    },
+  ],
+  indexes: [
+    { columns: ['sku'], name: 'idx_products_sku', unique: true },
+    { columns: ['category_id'], name: 'idx_products_category' },
+    {
+      columns: [
+        'price',
+        'stock',
+      ],
+      name: 'idx_products_active',
+      where: 'active = 1',
+    },
+  ],
+  name: 'products',
+  primaryKeys: ['id'],
 })
 ```
 
 ### Self-Referencing Table
 
 ```typescript
-const employees = createTable({
-  name: 'employees',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'name', schema: z.string() },
-    { name: 'email', schema: z.email(), unique: true },
-    { 
-      name: 'manager_id', 
-      schema: z.int().nullable(),
-      references: {
-        table: 'employees',
-        column: 'id',
-        onDelete: 'SET NULL'
-      }
-    }
-  ],
-  primaryKeys: ['id'],
-  indexes: [
-    { name: 'idx_employees_manager', columns: ['manager_id'] }
-  ]
+const employees = createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'name', schema: z.string() },
+    { name: 'email', schema: z.email(), unique: true },
+    {
+      name: 'manager_id',
+      references: {
+        column: 'id',
+        onDelete: 'SET NULL',
+        table: 'employees',
+      },
+      schema: z.int().nullable(),
+    },
+  ],
+  indexes: [{ columns: ['manager_id'], name: 'idx_employees_manager' }],
+  name: 'employees',
+  primaryKeys: ['id'],
 })
 ```
 
@@ -738,16 +768,21 @@ const employees = createTable({
 
 2. **Use appropriate types**: Choose the most specific Zod type that matches your data:
    ```typescript
-   z.int()           // For IDs and counts
-   z.number().min(0)          // For prices and quantities
-   z.enum(['a', 'b'])         // For status fields
-   z.email()         // For email addresses
+   z.int() // For IDs and counts
+   z.number().min(0) // For prices and quantities
+   z.enum([
+     'a',
+     'b',
+   ]) // For status fields
+   z.email() // For email addresses
    ```
 
 3. **Add validation at the schema level**: Leverage Zod's validation to prevent invalid data:
    ```typescript
-   z.string().min(3).max(50)  // Username length
-   z.number().min(0).max(5)   // Rating scale
+   z.string().min(3)
+     .max(50) // Username length
+   z.number().min(0)
+     .max(5) // Rating scale
    ```
 
 ### Foreign Keys
@@ -772,20 +807,23 @@ const employees = createTable({
 
 3. **Use composite indexes wisely**: Order matters - most selective column first:
    ```typescript
-   indexes: [
-     // Good: Filters by tenant first (high selectivity)
-     { name: 'idx_tenant_user', columns: ['tenant_id', 'user_id'] }
+   indexes: [
+     // Good: Filters by tenant first (high selectivity)
+     { columns: [
+       'tenant_id',
+       'user_id',
+     ], name: 'idx_tenant_user' },
    ]
    ```
 
 4. **Consider partial indexes**: Reduce index size for filtered queries:
    ```typescript
-   indexes: [
-     { 
-       name: 'idx_active_records', 
-       columns: ['created_at'],
-       where: 'deleted_at IS NULL'  // Only index active records
-     }
+   indexes: [
+     {
+       columns: ['created_at'],
+       name: 'idx_active_records',
+       where: 'deleted_at IS NULL', // Only index active records
+     },
    ]
    ```
 
@@ -809,15 +847,15 @@ const employees = createTable({
 
 1. **Use type inference**: Let TypeScript infer types from your schema:
    ```typescript
-   const { schema } = createTable(config)
+   const { schema } = createTable(config)
    type User = z.infer<typeof schema>
    ```
 
 2. **Validate at boundaries**: Use the generated schema to validate external data:
    ```typescript
-   const result = users.schema.safeParse(inputData)
-   if (!result.success) {
-     console.error(result.error)
+   const result = users.schema.safeParse(inputData)
+   if (!result.success) {
+     console.error(result.error)
    }
    ```
 
@@ -832,40 +870,43 @@ Single-column foreign keys are supported at the column level. Composite foreign
 **Pattern for composite foreign keys:**
 
 ```typescript
-// 1. Create parent table with composite primary key
-const { table: ordersTable } = createTable({
-  name: 'orders',
-  columns: [
-    { name: 'tenant_id', schema: z.string() },
-    { name: 'order_id', schema: z.int() },
-    { name: 'total', schema: z.number() },
-  ],
-  primaryKeys: ['tenant_id', 'order_id'],
-})
-
-// 2. Create child table with matching columns
-const { table: itemsTable } = createTable({
-  name: 'order_items',
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'tenant_id', schema: z.string() },
-    { name: 'order_id', schema: z.int() },
-    { name: 'product', schema: z.string() },
-  ],
-  primaryKeys: ['id'],
-})
-
-// 3. Execute table creation
-db.exec(ordersTable)
-db.exec(itemsTable)
-
-// 4. Add composite foreign key constraint
-db.exec(`
-  ALTER TABLE order_items 
-  ADD CONSTRAINT fk_order 
-  FOREIGN KEY (tenant_id, order_id) 
-  REFERENCES orders(tenant_id, order_id)
-  ON DELETE CASCADE
+// 1. Create parent table with composite primary key
+const { table: ordersTable } = createTable({
+  columns: [
+    { name: 'tenant_id', schema: z.string() },
+    { name: 'order_id', schema: z.int() },
+    { name: 'total', schema: z.number() },
+  ],
+  name: 'orders',
+  primaryKeys: [
+    'tenant_id',
+    'order_id',
+  ],
+})
+
+// 2. Create child table with matching columns
+const { table: itemsTable } = createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'tenant_id', schema: z.string() },
+    { name: 'order_id', schema: z.int() },
+    { name: 'product', schema: z.string() },
+  ],
+  name: 'order_items',
+  primaryKeys: ['id'],
+})
+
+// 3. Execute table creation
+db.exec(ordersTable)
+db.exec(itemsTable)
+
+// 4. Add composite foreign key constraint
+db.exec(`
+  ALTER TABLE order_items 
+  ADD CONSTRAINT fk_order 
+  FOREIGN KEY (tenant_id, order_id) 
+  REFERENCES orders(tenant_id, order_id)
+  ON DELETE CASCADE
 `)
 ```
 
@@ -878,7 +919,7 @@ Only specific Zod validations generate CHECK constraints:
 
 Custom refinements and complex validations work at the application level but don't generate SQL constraints:
 
-```typescript
+```plaintext
 { 
   name: 'email', 
   schema: z.string().refine(val => val.includes('@'), 'Must contain @')
@@ -894,7 +935,7 @@ Custom refinements and complex validations work at the application level but don
 
 Arrays and objects are stored as TEXT with JSON serialization. You must handle serialization manually:
 
-```typescript
+```plaintext
 { name: 'tags', schema: z.array(z.string()) }
 // SQL: tags TEXT NOT NULL
 
@@ -908,7 +949,7 @@ const tags = JSON.parse(result.tags) // ['tech', 'news']
 
 **Recommendation:** For better queryability, consider separate tables for array data:
 ```typescript
-// Instead of storing tags as JSON array
+// Instead of storing tags as JSON array
 // Use a junction table: post_tags (post_id, tag_id)
 ```
 
@@ -916,7 +957,7 @@ const tags = JSON.parse(result.tags) // ['tech', 'news']
 
 Dates are stored as TEXT in ISO 8601 format. SQLite doesn't have a native DATE type:
 
-```typescript
+```plaintext
 { name: 'created_at', schema: z.date() }
 // SQL: created_at DATE NOT NULL
 // Stored as TEXT: '2026-01-07T12:30:00.000Z'
@@ -961,12 +1002,12 @@ This tool is designed specifically for SQLite. Some features may not translate t
 **Critical:** SQLite does not enforce foreign key constraints by default. You must enable them:
 
 ```typescript
-// Example using db0
-const db = createDatabase(sqlite({ 
-  name: './db.sqlite',
-}))
-
-// Enable for each database connection
+// Example using db0
+const db = createDatabase(sqlite({
+  name: './db.sqlite',
+}))
+
+// Enable for each database connection
 db.exec('PRAGMA foreign_keys = ON')
 ```