zod-sqlite 1.0.3 → 1.0.5

package/README.md

@@ -1,10 +1,9 @@
 <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>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.</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/dm/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>
@@ -58,45 +57,47 @@ npm install zod-sqlite
 Here's a simple example creating a users table:
 
 ```typescript
-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>
+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 }
 ```
 
@@ -114,7 +115,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 }
 ```
 
@@ -142,7 +143,7 @@ Creates a table definition with SQL statements and validation schema.
 
 **Returns:**
 
-```
+```plaintext
 {
   table: string        // CREATE TABLE SQL statement
   indexes: string[]    // Array of CREATE INDEX statements
@@ -153,14 +154,14 @@ Creates a table definition with SQL statements and validation schema.
 **Example:**
 
 ```typescript
-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'],
+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'],
 })
 ```
 
@@ -169,11 +170,11 @@ const { indexes, schema, table } = createTable({
 Configuration object for table creation.
 
 ```typescript
-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
+interface TableConfig {
+  columns: ColumnConfig[] // Array of column definitions
+  indexes?: IndexConfig[] // Optional index configurations
+  name: string // Table name
+  primaryKeys: string[] // Column names forming primary key
 }
 ```
 
@@ -182,11 +183,11 @@ interface TableConfig {
 Configuration for a single column.
 
 ```typescript
-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
+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
 }
 ```
 
@@ -195,19 +196,19 @@ interface ColumnConfig {
 Foreign key constraint configuration.
 
 ```typescript
-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'
+
+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
@@ -215,11 +216,11 @@ type ForeignKeyAction
 Index configuration for query optimization.
 
 ```typescript
-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
+interface IndexConfig {
+  columns: string[] // Indexed column names
+  name: string // Index name
+  unique?: boolean // Whether this is a unique index
+  where?: string // Optional WHERE clause for partial index
 }
 ```
 
@@ -271,9 +272,9 @@ 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()
+z.string().optional() // TEXT (nullable)
+z.number().default(0) // REAL NOT NULL DEFAULT 0
+z.string().nullable()
   .default('n/a') // TEXT DEFAULT 'n/a'
 ```
 
@@ -281,14 +282,14 @@ z.string().nullable()
 
 ### Basic Columns
 
-```
+```plaintext
 { name: 'email', schema: z.email() }
 // SQL: email TEXT NOT NULL
 ```
 
 ### Optional and Nullable Columns
 
-```
+```plaintext
 { name: 'bio', schema: z.string().optional() }
 // SQL: bio TEXT
 
@@ -298,7 +299,7 @@ z.string().nullable()
 
 ### Columns with Default Values
 
-```
+```plaintext
 { name: 'status', schema: z.enum(['active', 'inactive']).default('active') }
 // SQL: status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'inactive'))
 
@@ -308,7 +309,7 @@ z.string().nullable()
 
 ### Unique Columns
 
-```
+```plaintext
 { name: 'username', schema: z.string(), unique: true }
 // SQL: username TEXT NOT NULL UNIQUE
 ```
@@ -319,7 +320,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### Enum Constraints
 
-```
+```plaintext
 { 
   name: 'role', 
   schema: z.enum(['admin', 'user', 'guest']) 
@@ -329,7 +330,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### Literal Constraints
 
-```
+```plaintext
 { 
   name: 'type', 
   schema: z.literal('premium') 
@@ -349,7 +350,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### Numeric Range Constraints
 
-```
+```plaintext
 { 
   name: 'age', 
   schema: z.int().min(18).max(120) 
@@ -365,7 +366,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### String Length Constraints
 
-```
+```plaintext
 { 
   name: 'username', 
   schema: z.string().min(3).max(20) 
@@ -386,14 +387,14 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 The most common pattern for entity tables:
 
 ```typescript
-createTable({
-  columns: [
-    { name: 'id', schema: z.int() },
-    { name: 'email', schema: z.string() },
-  ],
-  name: 'users',
-  primaryKeys: ['id'],
-})
+createTable({
+  columns: [
+    { name: 'id', schema: z.int() },
+    { name: 'email', schema: z.string() },
+  ],
+  name: 'users',
+  primaryKeys: ['id'],
+})
 // SQL: PRIMARY KEY (id)
 ```
 
@@ -402,35 +403,35 @@ createTable({
 Used for junction tables and multi-tenant data:
 
 ```typescript
-createTable({
-  columns: [
-    { name: 'user_id', schema: z.int() },
-    { name: 'role_id', schema: z.int() },
-  ],
-  name: 'user_roles',
-  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({
-  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',
-  ],
-})
+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)
 ```
 
@@ -439,21 +440,21 @@ createTable({
 ### Basic Foreign Key
 
 ```typescript
-createTable({
-  columns: [
-    { name: 'id', schema: z.int() },
-    {
-      name: 'author_id',
-      references: {
-        column: 'id',
-        table: 'users',
-      },
-      schema: z.int(),
-    },
-  ],
-  name: 'posts',
-  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)
 ```
 
@@ -461,7 +462,7 @@ createTable({
 
 Automatically delete child records when parent is deleted:
 
-```
+```plaintext
 {
   name: 'user_id',
   schema: z.int(),
@@ -478,7 +479,7 @@ Automatically delete child records when parent is deleted:
 
 Prevent deletion of parent if children exist:
 
-```
+```plaintext
 {
   name: 'category_id',
   schema: z.int(),
@@ -495,7 +496,7 @@ Prevent deletion of parent if children exist:
 
 Set foreign key to NULL when parent is deleted:
 
-```
+```plaintext
 {
   name: 'manager_id',
   schema: z.int().nullable(),
@@ -512,7 +513,7 @@ Set foreign key to NULL when parent is deleted:
 
 Propagate updates to child records:
 
-```
+```plaintext
 {
   name: 'parent_id',
   schema: z.int(),
@@ -530,7 +531,7 @@ Propagate updates to child records:
 
 ### Simple Index
 
-```
+```plaintext
 indexes: [
   {
     columns: ['email'],
@@ -545,13 +546,13 @@ indexes: [
 Enforce uniqueness at the database level:
 
 ```typescript
-indexes: [
-  {
-    columns: ['username'],
-    name: 'idx_users_username',
-    unique: true,
-  },
-]
+indexes: [
+  {
+    columns: ['username'],
+    name: 'idx_users_username',
+    unique: true,
+  },
+]
 // SQL: CREATE UNIQUE INDEX idx_users_username ON users (username);
 ```
 
@@ -560,15 +561,15 @@ indexes: [
 Index multiple columns together for multi-column queries:
 
 ```typescript
-indexes: [
-  {
-    columns: [
-      'author_id',
-      'created_at',
-    ],
-    name: 'idx_posts_author_date',
-  },
-]
+indexes: [
+  {
+    columns: [
+      'author_id',
+      'created_at',
+    ],
+    name: 'idx_posts_author_date',
+  },
+]
 // SQL: CREATE INDEX idx_posts_author_date ON posts (author_id, created_at);
 ```
 
@@ -583,13 +584,13 @@ SELECT * FROM posts WHERE author_id = 123 AND created_at > '2024-01-01';
 Index only rows matching a condition:
 
 ```typescript
-indexes: [
-  {
-    columns: ['last_login'],
-    name: 'idx_active_users',
-    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;
 ```
 
@@ -603,160 +604,160 @@ Benefits:
 ### Complete Blog Example
 
 ```typescript
-// 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',
-  ],
+// 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({
-  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'],
+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({
-  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'],
+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'],
 })
 ```
 
@@ -768,20 +769,20 @@ 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.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)
+   z.string().min(3)
+     .max(50) // Username length
+   z.number().min(0)
      .max(5) // Rating scale
    ```
 
@@ -807,23 +808,23 @@ const employees = createTable({
 
 3. **Use composite indexes wisely**: Order matters - most selective column first:
    ```typescript
-   indexes: [
-     // Good: Filters by tenant first (high selectivity)
-     { columns: [
-       'tenant_id',
-       'user_id',
-     ], name: 'idx_tenant_user' },
+   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: [
-     {
-       columns: ['created_at'],
-       name: 'idx_active_records',
-       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
+     },
    ]
    ```
 
@@ -847,15 +848,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)
    }
    ```
 
@@ -870,43 +871,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({
-  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
+// 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
 `)
 ```
 
@@ -919,7 +920,7 @@ Only specific Zod validations generate CHECK constraints:
 
 Custom refinements and complex validations work at the application level but don't generate SQL constraints:
 
-```
+```plaintext
 { 
   name: 'email', 
   schema: z.string().refine(val => val.includes('@'), 'Must contain @')
@@ -935,7 +936,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:
 
-```
+```plaintext
 { name: 'tags', schema: z.array(z.string()) }
 // SQL: tags TEXT NOT NULL
 
@@ -949,15 +950,17 @@ 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
-// Use a junction table: post_tags (post_id, tag_id)
+/*
+ * Instead of storing tags as JSON array
+ * Use a junction table: post_tags (post_id, tag_id)
+ */
 ```
 
 ### Date Handling
 
 Dates are stored as TEXT in ISO 8601 format. SQLite doesn't have a native DATE type:
 
-```
+```plaintext
 { name: 'created_at', schema: z.date() }
 // SQL: created_at DATE NOT NULL
 // Stored as TEXT: '2026-01-07T12:30:00.000Z'
@@ -1002,12 +1005,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')
 ```