zod-sqlite 1.0.4 → 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>
@@ -76,13 +75,15 @@ const users = createTable({
 
 // 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)
-// );
+/*
+ * 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);
@@ -170,10 +171,10 @@ Configuration object for table creation.
 
 ```typescript
 interface TableConfig {
-  columns: Array<ColumnConfig> // Array of column definitions
-  indexes?: Array<IndexConfig> // Optional index configurations
+  columns: ColumnConfig[] // Array of column definitions
+  indexes?: IndexConfig[] // Optional index configurations
   name: string // Table name
-  primaryKeys: Array<string> // Column names forming primary key
+  primaryKeys: string[] // Column names forming primary key
 }
 ```
 
@@ -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'
+    | '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
+}
 ```
 
 ### IndexConfig
@@ -216,7 +217,7 @@ Index configuration for query optimization.
 
 ```typescript
 interface IndexConfig {
-  columns: Array<string> // Indexed column names
+  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
@@ -949,8 +950,10 @@ 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

package/dist/index.d.mts

@@ -1,22 +1,134 @@
 import * as zod from "zod/v4/core";
-//#region src/types.d.ts
 /**
- * SQLite native column types.
+ * Database column configuration.
  *
- * SQLite uses a dynamic type system with these five storage classes.
- * Column values are stored in one of these formats, and SQLite performs
- * type conversions as needed during operations.
- * @see https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
- */
-type SQLiteType = 'BLOB' | 'INTEGER' | 'NULL' | 'REAL' | 'TEXT';
-/**
- * SQLite supported column types.
+ * Defines a single column in a table, including its name, type (via Zod schema),
+ * validation rules, and optional constraints like uniqueness and foreign keys.
  *
- * These types are supported by SQLite but not as native storage classes.
- * They are often used as aliases for other types or for specific purposes.
- * @see https://www.sqlite.org/datatype3.html#type_affinity
+ * **Column definition workflow:**
+ * 1. Zod schema is analyzed to determine SQLite type (TEXT, INTEGER, etc.)
+ * 2. Zod schema provides TypeScript type safety and runtime validation
+ * 3. Constraints (unique, foreign key) are applied at the database level
+ * @template TName - Literal string type for the column name
+ * @template TSchema - Zod type for the column schema
+ * @example
+ * ```ts
+ * // Simple text column
+ * {
+ *   name: 'email',
+ *   schema: z.email()
+ * }
+ *
+ * // Unique column with validation
+ * {
+ *   name: 'username',
+ *   schema: z.string().min(3).max(20),
+ *   unique: true
+ * }
+ *
+ * // Foreign key column
+ * {
+ *   name: 'author_id',
+ *   schema: z.int(),
+ *   references: {
+ *     table: 'users',
+ *     column: 'id',
+ *     onDelete: 'CASCADE'
+ *   }
+ * }
+ *
+ * // Optional column with default
+ * {
+ *   name: 'status',
+ *   schema: z.enum(['draft', 'published']).default('draft')
+ * }
+ * ```
  */
-type SQLiteSupportType = 'BIGINT' | 'BOOLEAN' | 'DATE' | 'DATETIME' | 'FLOAT' | 'NUMERIC';
+export interface ColumnConfig<TName extends string = string, TSchema extends zod.$ZodType = zod.$ZodType> {
+  /**
+   * Name of the column.
+   *
+   * Used in CREATE TABLE statement and all SQL queries.
+   * Should use snake_case by convention.
+   * @example 'user_id'
+   * @example 'created_at'
+   */
+  name: TName;
+  /**
+   * Foreign key reference configuration.
+   *
+   * Creates a constraint linking this column to a column in another table.
+   * Ensures referential integrity by preventing orphaned records.
+   *
+   * **Requirements:**
+   * - Referenced column should typically be a PRIMARY KEY or UNIQUE
+   * - Types must be compatible between the two columns
+   * - Foreign keys must be enabled: `PRAGMA foreign_keys = ON`
+   *
+   * **Composite foreign keys** (multiple columns referencing multiple columns)
+   * cannot be defined here - they must be defined at the table level as a
+   * separate constraint.
+   * @example
+   * ```ts
+   * {
+   *   name: 'user_id',
+   *   schema: z.int(),
+   *   references: {
+   *     table: 'users',
+   *     column: 'id',
+   *     onDelete: 'CASCADE'
+   *   }
+   * }
+   * ```
+   */
+  references?: ForeignKeyReference;
+  /**
+   * Zod schema defining the column's type, validation, and constraints.
+   *
+   * The Zod schema serves dual purposes:
+   * 1. **Database level**: Mapped to SQLite type (TEXT, INTEGER, REAL, BLOB, NULL)
+   * 2. **Application level**: Provides TypeScript types and runtime validation
+   *
+   * **Zod to SQLite type mapping:**
+   * - `z.string()`, `z.enum()`, `z.literal()`, `z.date()` → TEXT
+   * - `z.number()` → REAL (or INTEGER if `.int()` is used)
+   * - `z.bigint()`, `z.boolean()` → INTEGER
+   * - `z.custom()` for file/blob → BLOB
+   * - `z.null()`, `z.undefined()` → NULL
+   *
+   * **Zod features mapped to SQL:**
+   * - `.optional()`, `.nullable()` → column allows NULL
+   * - `.default(value)` → DEFAULT clause in SQL
+   * - `.min()`, `.max()`, `.email()`, etc. → runtime validation only
+   * @example z.string() - TEXT column
+   * @example z.int() - INTEGER column
+   * @example z.string().nullable() - TEXT column that allows NULL
+   * @example z.boolean().default(false) - INTEGER with DEFAULT 0
+   */
+  schema: TSchema;
+  /**
+   * Whether column values must be unique across all rows.
+   *
+   * When true, adds a UNIQUE constraint to the column. Any attempt to
+   * INSERT or UPDATE a duplicate value will fail.
+   *
+   * **Note**: This is different from PRIMARY KEY:
+   * - UNIQUE columns can be NULL (unless also NOT NULL)
+   * - A table can have multiple UNIQUE columns
+   * - PRIMARY KEY implies UNIQUE + NOT NULL
+   * @default false
+   * @example
+   * ```ts
+   * // Unique email address
+   * {
+   *   name: 'email',
+   *   schema: z.email(),
+   *   unique: true
+   * }
+   * ```
+   */
+  unique?: boolean;
+}
 /**
  * Foreign key constraint actions for ON DELETE and ON UPDATE clauses.
  *
@@ -50,7 +162,7 @@ type SQLiteSupportType = 'BIGINT' | 'BOOLEAN' | 'DATE' | 'DATETIME' | 'FLOAT' |
  * }
  * ```
  */
-type ForeignKeyAction = 'CASCADE' | 'NO ACTION' | 'RESTRICT' | 'SET DEFAULT' | 'SET NULL';
+export type ForeignKeyAction = 'CASCADE' | 'NO ACTION' | 'RESTRICT' | 'SET DEFAULT' | 'SET NULL';
 /**
  * Foreign key reference configuration.
  *
@@ -80,13 +192,7 @@ type ForeignKeyAction = 'CASCADE' | 'NO ACTION' | 'RESTRICT' | 'SET DEFAULT' | '
  * }
  * ```
  */
-interface ForeignKeyReference {
-  /**
-   * Name of the referenced table.
-   *
-   * This is the parent table that contains the column being referenced.
-   */
-  table: string;
+export interface ForeignKeyReference {
   /**
    * Name of the referenced column in the parent table.
    *
@@ -109,6 +215,12 @@ interface ForeignKeyReference {
    * @default 'NO ACTION'
    */
   onUpdate?: ForeignKeyAction;
+  /**
+   * Name of the referenced table.
+   *
+   * This is the parent table that contains the column being referenced.
+   */
+  table: string;
 }
 /**
  * Database index configuration.
@@ -152,7 +264,16 @@ interface ForeignKeyReference {
  * }
  * ```
  */
-interface IndexConfig<TColumns extends ReadonlyArray<ColumnConfig<string, zod.$ZodType>> = ReadonlyArray<ColumnConfig<string, zod.$ZodType>>> {
+export interface IndexConfig<TColumns extends readonly ColumnConfig<string, zod.$ZodType>[] = readonly ColumnConfig<string, zod.$ZodType>[]> {
+  /**
+   * Column names to include in the index.
+   *
+   * For composite indexes, the order matters: queries that filter on the
+   * first columns benefit most from the index.
+   * @example ['email'] - single column
+   * @example ['last_name', 'first_name'] - composite index
+   */
+  columns: readonly TColumns[number]['name'][];
   /**
    * Unique name for the index.
    *
@@ -162,15 +283,6 @@ interface IndexConfig<TColumns extends ReadonlyArray<ColumnConfig<string, zod.$Z
    * @example 'idx_posts_author_created'
    */
   name: string;
-  /**
-   * Column names to include in the index.
-   *
-   * For composite indexes, the order matters: queries that filter on the
-   * first columns benefit most from the index.
-   * @example ['email'] - single column
-   * @example ['last_name', 'first_name'] - composite index
-   */
-  columns: ReadonlyArray<TColumns[number]['name']>;
   /**
    * Whether this is a unique index.
    *
@@ -195,155 +307,27 @@ interface IndexConfig<TColumns extends ReadonlyArray<ColumnConfig<string, zod.$Z
   where?: string;
 }
 /**
- * Database column configuration.
- *
- * Defines a single column in a table, including its name, type (via Zod schema),
- * validation rules, and optional constraints like uniqueness and foreign keys.
- *
- * **Column definition workflow:**
- * 1. Zod schema is analyzed to determine SQLite type (TEXT, INTEGER, etc.)
- * 2. Zod schema provides TypeScript type safety and runtime validation
- * 3. Constraints (unique, foreign key) are applied at the database level
- * @template TName - Literal string type for the column name
- * @template TSchema - Zod type for the column schema
- * @example
- * ```ts
- * // Simple text column
- * {
- *   name: 'email',
- *   schema: z.email()
- * }
- *
- * // Unique column with validation
- * {
- *   name: 'username',
- *   schema: z.string().min(3).max(20),
- *   unique: true
- * }
+ * SQLite supported column types.
  *
- * // Foreign key column
- * {
- *   name: 'author_id',
- *   schema: z.int(),
- *   references: {
- *     table: 'users',
- *     column: 'id',
- *     onDelete: 'CASCADE'
- *   }
- * }
+ * These types are supported by SQLite but not as native storage classes.
+ * They are often used as aliases for other types or for specific purposes.
+ * @see https://www.sqlite.org/datatype3.html#type_affinity
+ */
+export type SQLiteSupportType = 'BIGINT' | 'BOOLEAN' | 'DATE' | 'DATETIME' | 'FLOAT' | 'NUMERIC';
+/**
+ * SQLite native column types.
  *
- * // Optional column with default
- * {
- *   name: 'status',
- *   schema: z.enum(['draft', 'published']).default('draft')
- * }
- * ```
+ * SQLite uses a dynamic type system with these five storage classes.
+ * Column values are stored in one of these formats, and SQLite performs
+ * type conversions as needed during operations.
+ * @see https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
  */
-interface ColumnConfig<TName extends string = string, TSchema extends zod.$ZodType = zod.$ZodType> {
-  /**
-   * Name of the column.
-   *
-   * Used in CREATE TABLE statement and all SQL queries.
-   * Should use snake_case by convention.
-   * @example 'user_id'
-   * @example 'created_at'
-   */
-  name: TName;
-  /**
-   * Zod schema defining the column's type, validation, and constraints.
-   *
-   * The Zod schema serves dual purposes:
-   * 1. **Database level**: Mapped to SQLite type (TEXT, INTEGER, REAL, BLOB, NULL)
-   * 2. **Application level**: Provides TypeScript types and runtime validation
-   *
-   * **Zod to SQLite type mapping:**
-   * - `z.string()`, `z.enum()`, `z.literal()`, `z.date()` → TEXT
-   * - `z.number()` → REAL (or INTEGER if `.int()` is used)
-   * - `z.bigint()`, `z.boolean()` → INTEGER
-   * - `z.custom()` for file/blob → BLOB
-   * - `z.null()`, `z.undefined()` → NULL
-   *
-   * **Zod features mapped to SQL:**
-   * - `.optional()`, `.nullable()` → column allows NULL
-   * - `.default(value)` → DEFAULT clause in SQL
-   * - `.min()`, `.max()`, `.email()`, etc. → runtime validation only
-   * @example z.string() - TEXT column
-   * @example z.int() - INTEGER column
-   * @example z.string().nullable() - TEXT column that allows NULL
-   * @example z.boolean().default(false) - INTEGER with DEFAULT 0
-   */
-  schema: TSchema;
-  /**
-   * Whether column values must be unique across all rows.
-   *
-   * When true, adds a UNIQUE constraint to the column. Any attempt to
-   * INSERT or UPDATE a duplicate value will fail.
-   *
-   * **Note**: This is different from PRIMARY KEY:
-   * - UNIQUE columns can be NULL (unless also NOT NULL)
-   * - A table can have multiple UNIQUE columns
-   * - PRIMARY KEY implies UNIQUE + NOT NULL
-   * @default false
-   * @example
-   * ```ts
-   * // Unique email address
-   * {
-   *   name: 'email',
-   *   schema: z.email(),
-   *   unique: true
-   * }
-   * ```
-   */
-  unique?: boolean;
-  /**
-   * Foreign key reference configuration.
-   *
-   * Creates a constraint linking this column to a column in another table.
-   * Ensures referential integrity by preventing orphaned records.
-   *
-   * **Requirements:**
-   * - Referenced column should typically be a PRIMARY KEY or UNIQUE
-   * - Types must be compatible between the two columns
-   * - Foreign keys must be enabled: `PRAGMA foreign_keys = ON`
-   *
-   * **Composite foreign keys** (multiple columns referencing multiple columns)
-   * cannot be defined here - they must be defined at the table level as a
-   * separate constraint.
-   * @example
-   * ```ts
-   * {
-   *   name: 'user_id',
-   *   schema: z.int(),
-   *   references: {
-   *     table: 'users',
-   *     column: 'id',
-   *     onDelete: 'CASCADE'
-   *   }
-   * }
-   * ```
-   */
-  references?: ForeignKeyReference;
-}
+export type SQLiteType = 'BLOB' | 'INTEGER' | 'NULL' | 'REAL' | 'TEXT';
 /**
  * Complete database table configuration.
  * @template TColumns - An array of column configuration objects.
  */
-interface TableConfig<TColumns extends ReadonlyArray<ColumnConfig<string, zod.$ZodType>> = ReadonlyArray<ColumnConfig<string, zod.$ZodType>>> {
-  /**
-   * Name of the table.
-   *
-   * Used in CREATE TABLE statement and all SQL queries.
-   * Should use snake_case by convention (e.g., 'user_profiles', 'order_items').
-   *
-   * **Naming conventions:**
-   * - Use plural nouns for tables representing collections (e.g., 'users', 'posts')
-   * - Use singular nouns for junction tables (e.g., 'user_role', 'post_tag')
-   * - Avoid SQL reserved keywords (e.g., 'order' → 'orders' or 'user_order')
-   * @example 'users'
-   * @example 'blog_posts'
-   * @example 'user_sessions'
-   */
-  name: string;
+export interface TableConfig<TColumns extends readonly ColumnConfig<string, zod.$ZodType>[] = readonly ColumnConfig<string, zod.$ZodType>[]> {
   /**
    * Array of column configurations defining the table structure.
    *
@@ -366,35 +350,6 @@ interface TableConfig<TColumns extends ReadonlyArray<ColumnConfig<string, zod.$Z
    * ```
    */
   columns: TColumns;
-  /**
-   * Column name(s) that form the primary key.
-   *
-   * The primary key uniquely identifies each row in the table and cannot
-   * contain NULL values. Always provided as an array, even for single-column
-   * primary keys.
-   *
-   * **Single column primary key:**
-   * - Use an array with one element (e.g., `['id']`)
-   * - Typically an auto-incrementing integer
-   * - Most common pattern for standard entity tables
-   *
-   * **Composite primary key:**
-   * - Use an array with multiple elements (e.g., `['user_id', 'post_id']`)
-   * - Common in junction tables for many-to-many relationships
-   * - Order matters: most specific/selective column should come first
-   * - The combination of all columns must be unique
-   *
-   * **Notes:**
-   * - Every table should have a primary key
-   * - Primary key columns are automatically indexed by SQLite
-   * - Primary key implies UNIQUE + NOT NULL constraints on all columns
-   * - Cannot be changed after table creation (requires table rebuild)
-   * @example ['id'] - single column primary key
-   * @example ['user_id', 'role_id'] - composite primary key for junction table
-   * @example ['tenant_id', 'record_id'] - composite key for multi-tenant data
-   * @example ['country_code', 'postal_code'] - composite key for location data
-   */
-  primaryKeys: ReadonlyArray<TColumns[number]['name']>;
   /**
    * Optional array of index configurations for query optimization.
    *
@@ -433,10 +388,52 @@ interface TableConfig<TColumns extends ReadonlyArray<ColumnConfig<string, zod.$Z
    * ]
    * ```
    */
-  indexes?: Array<IndexConfig<TColumns>>;
+  indexes?: IndexConfig<TColumns>[];
+  /**
+   * Name of the table.
+   *
+   * Used in CREATE TABLE statement and all SQL queries.
+   * Should use snake_case by convention (e.g., 'user_profiles', 'order_items').
+   *
+   * **Naming conventions:**
+   * - Use plural nouns for tables representing collections (e.g., 'users', 'posts')
+   * - Use singular nouns for junction tables (e.g., 'user_role', 'post_tag')
+   * - Avoid SQL reserved keywords (e.g., 'order' → 'orders' or 'user_order')
+   * @example 'users'
+   * @example 'blog_posts'
+   * @example 'user_sessions'
+   */
+  name: string;
+  /**
+   * Column name(s) that form the primary key.
+   *
+   * The primary key uniquely identifies each row in the table and cannot
+   * contain NULL values. Always provided as an array, even for single-column
+   * primary keys.
+   *
+   * **Single column primary key:**
+   * - Use an array with one element (e.g., `['id']`)
+   * - Typically an auto-incrementing integer
+   * - Most common pattern for standard entity tables
+   *
+   * **Composite primary key:**
+   * - Use an array with multiple elements (e.g., `['user_id', 'post_id']`)
+   * - Common in junction tables for many-to-many relationships
+   * - Order matters: most specific/selective column should come first
+   * - The combination of all columns must be unique
+   *
+   * **Notes:**
+   * - Every table should have a primary key
+   * - Primary key columns are automatically indexed by SQLite
+   * - Primary key implies UNIQUE + NOT NULL constraints on all columns
+   * - Cannot be changed after table creation (requires table rebuild)
+   * @example ['id'] - single column primary key
+   * @example ['user_id', 'role_id'] - composite primary key for junction table
+   * @example ['tenant_id', 'record_id'] - composite key for multi-tenant data
+   * @example ['country_code', 'postal_code'] - composite key for location data
+   */
+  primaryKeys: readonly TColumns[number]['name'][];
 }
-//#endregion
-//#region src/table.d.ts
 /**
  * Creates a table definition and Zod schema.
  *
@@ -449,12 +446,10 @@ interface TableConfig<TColumns extends ReadonlyArray<ColumnConfig<string, zod.$Z
  * @param config Table configuration object
  * @returns Object containing SQL statements and Zod schema
  */
-declare function createTable<const TColumns extends ReadonlyArray<ColumnConfig<any, any>>>(config: TableConfig<TColumns>): {
+export declare function createTable<const TColumns extends readonly ColumnConfig<any, any>[]>(config: TableConfig<TColumns>): {
   indexes: string[];
   schema: import("zod").ZodObject<{ [K in TColumns[number]["name"]]: Extract<TColumns[number], {
     name: K;
   }>["schema"]; }, import("zod/v4/core").$strip>;
   table: string;
-};
-//#endregion
-export { ColumnConfig, ForeignKeyAction, ForeignKeyReference, IndexConfig, SQLiteSupportType, SQLiteType, TableConfig, createTable };
+};

package/dist/index.mjs

@@ -1,283 +1,4 @@
-import { z } from "zod";
-//#region src/utils/format-check-constraint.ts
-/**
-* Generates formatted CHECK constraints for validatable columns.
-*
-* Supports:
-* - `z.enum()`: CHECK(col IN ('a', 'b'))
-* - `z.literal()`: CHECK(col = 'val')
-* - `z.number().min/max()`: CHECK(col >= min AND col <= max)
-* - `z.string().min/max()`: CHECK(length(col) >= min)
-* @param name Column name
-* @param schema Zod schema
-* @returns SQL CHECK constraint string or null
-*/
-function formatCheckConstraint(name, schema) {
-	let currentSchema = schema;
-	while (true) {
-		const def = currentSchema._zod.def;
-		if (def.type === "nullable" || def.type === "optional" || def.type === "default") currentSchema = def.innerType;
-		else break;
-	}
-	const definition = currentSchema._zod.def;
-	switch (definition.type) {
-		case "enum": {
-			const entries = definition.entries;
-			return `CHECK(${name} IN (${Object.values(entries).map((value) => `'${String(value).replaceAll("'", "''")}'`).join(", ")}))`;
-		}
-		case "literal": {
-			const values = definition.values;
-			if (values.length === 1) {
-				const value = values[0];
-				if (typeof value === "string") return `CHECK(${name} = '${value.replaceAll("'", "''")}')`;
-				return `CHECK(${name} = ${value})`;
-			}
-			return `CHECK(${name} IN (${values.map((value) => {
-				if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
-				return String(value);
-			}).join(", ")}))`;
-		}
-		case "number": {
-			const checks = definition.checks;
-			const constraints = [];
-			if (!checks) return;
-			for (const check of checks) {
-				const checkParameters = check._zod.def.check;
-				const checkValue = check._zod.def.value;
-				switch (checkParameters) {
-					case "greater_than":
-						constraints.push(`${name} >= ${checkValue}`);
-						break;
-					case "less_than": constraints.push(`${name} <= ${checkValue}`);
-				}
-			}
-			return constraints.length > 0 ? `CHECK(${constraints.join(" AND ")})` : void 0;
-		}
-		case "string": {
-			const checks = definition.checks;
-			const constraints = [];
-			if (!checks) return;
-			for (const check of checks) {
-				const checkParameters = check._zod.def.check;
-				const checkDefinition = check._zod.def;
-				switch (checkParameters) {
-					case "length_equals":
-						constraints.push(`length(${name}) = ${checkDefinition.length}`);
-						break;
-					case "max_length":
-						constraints.push(`length(${name}) <= ${checkDefinition.maximum}`);
-						break;
-					case "min_length": constraints.push(`length(${name}) >= ${checkDefinition.minimum}`);
-				}
-			}
-			return constraints.length > 0 ? `CHECK(${constraints.join(" AND ")})` : void 0;
-		}
-		case "union": {
-			const options = definition.options;
-			if (!options.every((option) => option._zod.def.type === "literal")) return;
-			const values = [];
-			for (const option of options) values.push(...option._zod.def.values);
-			return `CHECK(${name} IN (${values.map((value) => {
-				if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
-				return String(value);
-			}).join(", ")}))`;
-		}
-	}
-}
-//#endregion
-//#region src/utils/format-default-value.ts
-/**
-* Formats a default value for SQL.
-*
-* Handles string quoting and type conversions for DEFAULT clauses.
-* @param value The default value
-* @param SQLiteType Target column type
-* @returns Formatted SQL default string (e.g., "DEFAULT 'val'", "DEFAULT 42")
-*/
-function formatDefaultValue(value, SQLiteType) {
-	switch (SQLiteType) {
-		case "TEXT": return `DEFAULT '${String(value).replaceAll("'", "''")}'`;
-		case "INTEGER":
-		case "REAL": return `DEFAULT ${Number(value)}`;
-		case "BOOLEAN": return `DEFAULT ${value ? 1 : 0}`;
-		case "NULL": return "DEFAULT NULL";
-		default: return `DEFAULT '${value}'`;
-	}
-}
-//#endregion
-//#region src/utils/map-zod-type-to-sqlite.ts
-/**
-* Maps a Zod type to an SQLite column type.
-*
-* analyzes the Zod schema type and optionally its format (e.g., z.email())
-* to determine the most appropriate SQLite storage class or supported type.
-* @param zodType Zod type string (e.g., 'string', 'number')
-* @param schema The actual Zod schema instance
-* @returns SQLite column type
-*/
-function mapZodTypeToSQLite(zodType, schema) {
-	switch (zodType) {
-		case "string": switch (schema._zod.def.format) {
-			case "date": return "DATE";
-			case "datetime": return "DATETIME";
-			case "duration": return "INTEGER";
-			default: return "TEXT";
-		}
-		case "enum":
-		case "literal":
-		case "array":
-		case "template_literal":
-		case "object": return "TEXT";
-		case "date": return "DATE";
-		case "number": switch (schema._zod.def.format) {
-			case "safeint":
-			case "uint32":
-			case "int32": return "INTEGER";
-			case "float32":
-			case "float64": return "FLOAT";
-			default: return "REAL";
-		}
-		case "boolean": return "BOOLEAN";
-		case "bigint": return "BIGINT";
-		case "null":
-		case "undefined": return "NULL";
-		case "file": return "BLOB";
-		default: return "TEXT";
-	}
-}
-//#endregion
-//#region src/utils/zod-to-sqlite.ts
-/**
-* Analyzes a Zod schema to extract SQLite metadata.
-*
-* Unwraps optional/nullable/default layers to find the underlying core type
-* and extracts metadata like nullability and default values.
-* @param schema Zod schema to analyze
-* @returns Object containing SQLite type, nullability, default value, and inner schema
-*/
-function zodToSQLite(schema) {
-	let nullable = false;
-	let defaultValue;
-	let currentSchema = schema;
-	while (true) {
-		const definition = currentSchema._zod.def;
-		const zodType = definition.type;
-		if (zodType === "nullable" || zodType === "optional") {
-			nullable = true;
-			currentSchema = definition.innerType;
-		} else if (zodType === "default") {
-			defaultValue = typeof definition.defaultValue === "function" ? definition.defaultValue() : definition.defaultValue;
-			currentSchema = definition.innerType;
-		} else break;
-	}
-	const mainType = currentSchema._zod.def.type;
-	const SQLiteType = mapZodTypeToSQLite(mainType, currentSchema);
-	return {
-		defaultValue,
-		nullable,
-		schema,
-		SQLiteType
-	};
-}
-//#endregion
-//#region src/column-definitions.ts
-/**
-* Builds the SQL definition for a single column.
-*
-* Combines name, type, and constraints into a valid SQL column string.
-* @param column Column configuration object
-* @returns Complete column definition string (e.g., "id INTEGER NOT NULL")
-*/
-function buildColumnDefinition(column) {
-	const { name, references, schema, unique } = column;
-	const { defaultValue, nullable, SQLiteType } = zodToSQLite(schema);
-	const parts = [name, SQLiteType];
-	if (!nullable) parts.push("NOT NULL");
-	if (defaultValue !== void 0) parts.push(formatDefaultValue(defaultValue, SQLiteType));
-	if (unique) parts.push("UNIQUE");
-	const checkConstraint = formatCheckConstraint(name, schema);
-	if (checkConstraint) parts.push(checkConstraint);
-	if (references) {
-		const { column: refColumn, onDelete, onUpdate, table } = references;
-		parts.push(`REFERENCES ${table}(${refColumn})`);
-		if (onDelete) parts.push(`ON DELETE ${onDelete}`);
-		if (onUpdate) parts.push(`ON UPDATE ${onUpdate}`);
-	}
-	return parts.join(" ");
-}
-//#endregion
-//#region src/index-statements.ts
-/**
-* Generates SQL statements for table indexes.
-*
-* Creates standard, unique, and partial indexes based on configuration.
-* @param tableName Name of the table
-* @param indexes Array of index configurations
-* @returns Array of CREATE INDEX SQL statements
-*/
-function buildIndexStatements(tableName, indexes) {
-	if (!indexes || indexes.length === 0) return [];
-	return indexes.map((index) => {
-		const uniqueClause = index.unique ? "UNIQUE " : "";
-		const whereClause = index.where ? ` WHERE ${index.where}` : "";
-		return `CREATE ${uniqueClause}INDEX ${index.name} ON ${tableName} (${index.columns.join(", ")})${whereClause};`;
-	});
-}
-//#endregion
-//#region src/primary-key-constraint.ts
-/**
-* Builds the PRIMARY KEY constraint string.
-*
-* Handles both single-column and composite primary keys.
-* @param primaryKeys Array of column names forming the primary key
-* @returns SQL constraint string (e.g., "PRIMARY KEY (id, email)")
-*/
-function buildPrimaryKeyConstraint(primaryKeys) {
-	if (primaryKeys.length === 0) return "";
-	return `PRIMARY KEY (${primaryKeys.join(", ")})`;
-}
-//#endregion
-//#region src/zod-schema.ts
-/**
-* Builds a Zod schema from column definitions.
-*
-* Creates a Zod object schema where keys are column names and values are
-* the corresponding Zod schemas from the column configuration.
-* @template TColumns - Array of column configurations
-* @param columns Array of column configurations
-* @returns Zod object schema
-*/
-function buildZodSchema(columns) {
-	const schemaShape = {};
-	for (const column of columns) schemaShape[column.name] = column.schema;
-	return z.object(schemaShape);
-}
-//#endregion
-//#region src/table.ts
-/**
-* Creates a table definition and Zod schema.
-*
-* This function is the main entry point for defining a table. It takes a configuration object
-* and returns:
-* 1. `table`: SQL CREATE TABLE statement
-* 2. `indexes`: Array of SQL CREATE INDEX statements
-* 3. `schema`: Zod object schema matching the table structure
-* @template TColumns - Array of column configurations
-* @param config Table configuration object
-* @returns Object containing SQL statements and Zod schema
-*/
-function createTable(config) {
-	const { columns, indexes, name, primaryKeys } = config;
-	const columnDefs = columns.map((column) => buildColumnDefinition(column));
-	const primaryKeyConstraint = buildPrimaryKeyConstraint(primaryKeys);
-	const createTableSQL = `CREATE TABLE ${name} (
-  ${[...columnDefs, primaryKeyConstraint].filter(Boolean).join(",\n  ")}
-);`;
-	return {
-		indexes: buildIndexStatements(name, indexes),
-		schema: buildZodSchema(columns),
-		table: createTableSQL
-	};
-}
-//#endregion
-export { createTable };
+import{z as e}from"zod";function t(e,t){let n=t;for(;;){let e=n._zod.def;if(e.type===`nullable`||e.type===`optional`||e.type==="default")n=e.innerType;else break}let r=n._zod.def;switch(r.type){case`enum`:{let t=r.entries;return`CHECK(${e} IN (${Object.values(t).map(e=>`'${String(e).replaceAll(`'`,`''`)}'`).join(`, `)}))`}case`literal`:{let t=r.values;if(t.length===1){let n=t[0];return typeof n==`string`?`CHECK(${e} = '${n.replaceAll(`'`,`''`)}')`:`CHECK(${e} = ${n})`}return`CHECK(${e} IN (${t.map(e=>typeof e==`string`?`'${e.replaceAll(`'`,`''`)}'`:String(e)).join(`, `)}))`}case`number`:{let t=r.checks;if(!t)return;let n=[],i=(t,r)=>{switch(t){case`greater_than`:n.push(`${e} >= ${r}`);break;case`less_than`:n.push(`${e} <= ${r}`)}};for(let e of t){let t=e._zod.def.check,n=e._zod.def.value;i(t,n)}return n.length>0?`CHECK(${n.join(` AND `)})`:void 0}case`string`:{let t=r.checks;if(!t)return;let n=[],i=(t,r)=>{switch(t){case`length_equals`:n.push(`length(${e}) = ${r.length}`);break;case`max_length`:n.push(`length(${e}) <= ${r.maximum}`);break;case`min_length`:n.push(`length(${e}) >= ${r.minimum}`)}};for(let e of t){let t=e._zod.def.check,n=e._zod.def;i(t,n)}return n.length>0?`CHECK(${n.join(` AND `)})`:void 0}case`union`:{let t=r.options;if(!t.every(e=>e._zod.def.type===`literal`))return;let n=[];for(let e of t)n.push(...e._zod.def.values);return`CHECK(${e} IN (${n.map(e=>typeof e==`string`?`'${e.replaceAll(`'`,`''`)}'`:String(e)).join(`, `)}))`}}}function n(e,t){switch(t){case`TEXT`:return`DEFAULT '${String(e).replaceAll(`'`,`''`)}'`;case`INTEGER`:case`REAL`:return`DEFAULT ${Number(e)}`;case`BOOLEAN`:return`DEFAULT ${+!!e}`;case`NULL`:return`DEFAULT NULL`;default:return`DEFAULT '${e}'`}}function r(e,t){switch(e){case`string`:switch(t._zod.def.format){case`date`:return`DATE`;case`datetime`:return`DATETIME`;case`duration`:return`INTEGER`;default:return`TEXT`}case`enum`:case`literal`:case`array`:case`template_literal`:case`object`:return`TEXT`;case`date`:return`DATE`;case`number`:switch(t._zod.def.format){case`safeint`:case`uint32`:case`int32`:return`INTEGER`;case`float32`:case`float64`:return`FLOAT`;default:return`REAL`}case`boolean`:return`BOOLEAN`;case`bigint`:return`BIGINT`;case`null`:case`undefined`:return`NULL`;case`file`:return`BLOB`;default:return`TEXT`}}function i(e){let t=!1,n,i=e;for(;;){let e=i._zod.def,r=e.type;if(r===`nullable`||r===`optional`)t=!0,i=e.innerType;else if(r==="default")n=typeof e.defaultValue==`function`?e.defaultValue():e.defaultValue,i=e.innerType;else break}let a=i._zod.def.type,o=r(a,i);return{defaultValue:n,nullable:t,schema:e,SQLiteType:o}}function a(e){let{name:r,references:a,schema:o,unique:s}=e,{defaultValue:c,nullable:l,SQLiteType:u}=i(o),d=[r,u];l||d.push(`NOT NULL`),c!==void 0&&d.push(n(c,u)),s&&d.push(`UNIQUE`);let f=t(r,o);if(f&&d.push(f),a){let{column:e,onDelete:t,onUpdate:n,table:r}=a;d.push(`REFERENCES ${r}(${e})`),t&&d.push(`ON DELETE ${t}`),n&&d.push(`ON UPDATE ${n}`)}return d.join(` `)}function o(e,t){return!t||t.length===0?[]:t.map(t=>{let n=t.unique?`UNIQUE `:``,r=t.where?` WHERE ${t.where}`:``;return`CREATE ${n}INDEX ${t.name} ON ${e} (${t.columns.join(`, `)})${r};`})}function s(e){return e.length===0?``:`PRIMARY KEY (${e.join(`, `)})`}function c(t){let n={};for(let e of t)n[e.name]=e.schema;return e.object(n)}function l(e){let{columns:t,indexes:n,name:r,primaryKeys:i}=e,l=t.map(e=>a(e)),u=s(i),d=`CREATE TABLE ${r} (
+  ${[...l,u].filter(Boolean).join(`,
+  `)}
+);`;return{indexes:o(r,n),schema:c(t),table:d}}export{l as createTable};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zod-sqlite",
   "type": "module",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "private": false,
   "description": "Generate type-safe SQLite table schemas from Zod validation schemas.",
   "author": "Favour Emeka <favorodera@gmail.com>",
@@ -35,23 +35,22 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=22.0.0",
-    "pnpm": ">=11.0.0"
+    "node": ">=24.0.0"
   },
   "dependencies": {
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@favorodera/eslint-config": "^1.0.4",
+    "@favorodera/eslint-config": "^3.0.0",
     "@types/node": "^26.2.0",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "@vitest/ui": "4.1.10",
-    "db0": "^0.3.4",
+    "@vitest/ui": "5.0.5",
+    "db0": "^0.4.0",
     "eslint": "^10.8.1",
+    "pkg-pr-new": "^0.0.93",
     "relizy": "^1.4.9",
-    "tsdown": "^0.22.14",
+    "tsdown": "^0.23.0",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "build": "tsdown",
@@ -59,7 +58,8 @@
     "test": "vitest run",
     "test:watch": "vitest --watch --ui",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint . --fix",
+    "lint:fix": "eslint . --fix",
+    "lint": "eslint .",
     "ready": "pnpm install && pnpm lint && pnpm typecheck && pnpm test && pnpm build"
   }
 }