zod-sqlite 1.0.3 → 1.0.4

package/README.md

@@ -58,45 +58,45 @@ 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 +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 }
 ```
 
@@ -142,7 +142,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 +153,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 +169,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: Array<ColumnConfig> // Array of column definitions
+  indexes?: Array<IndexConfig> // Optional index configurations
+  name: string // Table name
+  primaryKeys: Array<string> // Column names forming primary key
 }
 ```
 
@@ -182,11 +182,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,18 +195,18 @@ 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'
+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'
 ```
 
@@ -215,11 +215,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: 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
 }
 ```
 
@@ -271,9 +271,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 +281,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 +298,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 +308,7 @@ z.string().nullable()
 
 ### Unique Columns
 
-```
+```plaintext
 { name: 'username', schema: z.string(), unique: true }
 // SQL: username TEXT NOT NULL UNIQUE
 ```
@@ -319,7 +319,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### Enum Constraints
 
-```
+```plaintext
 { 
   name: 'role', 
   schema: z.enum(['admin', 'user', 'guest']) 
@@ -329,7 +329,7 @@ SQL CHECK constraints are automatically generated from Zod validation rules.
 
 ### Literal Constraints
 
-```
+```plaintext
 { 
   name: 'type', 
   schema: z.literal('premium') 
@@ -349,7 +349,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 +365,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 +386,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 +402,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 +439,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 +461,7 @@ createTable({
 
 Automatically delete child records when parent is deleted:
 
-```
+```plaintext
 {
   name: 'user_id',
   schema: z.int(),
@@ -478,7 +478,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 +495,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 +512,7 @@ Set foreign key to NULL when parent is deleted:
 
 Propagate updates to child records:
 
-```
+```plaintext
 {
   name: 'parent_id',
   schema: z.int(),
@@ -530,7 +530,7 @@ Propagate updates to child records:
 
 ### Simple Index
 
-```
+```plaintext
 indexes: [
   {
     columns: ['email'],
@@ -545,13 +545,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 +560,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 +583,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 +603,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 +768,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 +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)
-     { 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 +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)
    }
    ```
 
@@ -870,43 +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({
-  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 +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:
 
-```
+```plaintext
 { 
   name: 'email', 
   schema: z.string().refine(val => val.includes('@'), 'Must contain @')
@@ -935,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:
 
-```
+```plaintext
 { name: 'tags', schema: z.array(z.string()) }
 // SQL: tags TEXT NOT NULL
 
@@ -949,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)
 ```
 
@@ -957,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:
 
-```
+```plaintext
 { name: 'created_at', schema: z.date() }
 // SQL: created_at DATE NOT NULL
 // Stored as TEXT: '2026-01-07T12:30:00.000Z'
@@ -1002,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')
 ```
 

package/dist/index.d.mts

@@ -1,5 +1,4 @@
 import * as zod from "zod/v4/core";
-
 //#region src/types.d.ts
 /**
  * SQLite native column types.
@@ -454,7 +453,7 @@ declare function createTable<const TColumns extends ReadonlyArray<ColumnConfig<a
   indexes: string[];
   schema: import("zod").ZodObject<{ [K in TColumns[number]["name"]]: Extract<TColumns[number], {
     name: K;
-  }>["schema"] }, import("zod/v4/core").$strip>;
+  }>["schema"]; }, import("zod/v4/core").$strip>;
   table: string;
 };
 //#endregion

package/dist/index.mjs

@@ -48,9 +48,7 @@ function formatCheckConstraint(name, schema) {
 					case "greater_than":
 						constraints.push(`${name} >= ${checkValue}`);
 						break;
-					case "less_than":
-						constraints.push(`${name} <= ${checkValue}`);
-						break;
+					case "less_than": constraints.push(`${name} <= ${checkValue}`);
 				}
 			}
 			return constraints.length > 0 ? `CHECK(${constraints.join(" AND ")})` : void 0;
@@ -69,9 +67,7 @@ function formatCheckConstraint(name, schema) {
 					case "max_length":
 						constraints.push(`length(${name}) <= ${checkDefinition.maximum}`);
 						break;
-					case "min_length":
-						constraints.push(`length(${name}) >= ${checkDefinition.minimum}`);
-						break;
+					case "min_length": constraints.push(`length(${name}) >= ${checkDefinition.minimum}`);
 				}
 			}
 			return constraints.length > 0 ? `CHECK(${constraints.join(" AND ")})` : void 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zod-sqlite",
   "type": "module",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "private": false,
   "description": "Generate type-safe SQLite table schemas from Zod validation schemas.",
   "author": "Favour Emeka <favorodera@gmail.com>",
@@ -42,16 +42,16 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@favorodera/eslint-config": "^1.0.0",
-    "@types/node": "^25.6.2",
-    "@typescript/native-preview": "7.0.0-dev.20260509.2",
-    "@vitest/ui": "4.1.8",
+    "@favorodera/eslint-config": "^1.0.4",
+    "@types/node": "^26.2.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "@vitest/ui": "4.1.10",
     "db0": "^0.3.4",
-    "eslint": "^10.4.1",
+    "eslint": "^10.8.1",
     "relizy": "^1.4.9",
-    "tsdown": "^0.22.0",
+    "tsdown": "^0.22.14",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "build": "tsdown",
@@ -60,6 +60,6 @@
     "test:watch": "vitest --watch --ui",
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --fix",
-    "ready": "pnpm install && pnpm build && pnpm lint && pnpm typecheck && pnpm test"
+    "ready": "pnpm install && pnpm lint && pnpm typecheck && pnpm test && pnpm build"
   }
 }