zod-sqlite 1.0.2 → 1.0.4

package/dist/index.mjs

@@ -0,0 +1,283 @@
+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 };

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "zod-sqlite",
-  "version": "1.0.2",
-  "description": "Generate type-safe SQLite table schemas from Zod validation schemas.",
+  "type": "module",
+  "version": "1.0.4",
   "private": false,
-  "author": {
-    "name": "Favour Emeka",
-    "email": "favor.emeka@minibase.com",
-    "url": "https://github.com/favorodera"
-  },
+  "description": "Generate type-safe SQLite table schemas from Zod validation schemas.",
+  "author": "Favour Emeka <favorodera@gmail.com>",
   "license": "MIT",
+  "funding": "https://github.com/sponsors/favorodera",
+  "homepage": "https://github.com/favorodera/zod-sqlite#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/favorodera/zod-sqlite.git"
@@ -16,67 +15,51 @@
   "bugs": {
     "url": "https://github.com/favorodera/zod-sqlite/issues"
   },
-  "homepage": "https://github.com/favorodera/zod-sqlite#readme",
-  "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "keywords": [
+    "zod",
+    "sqlite",
+    "database",
+    "schema",
+    "validation",
+    "zod-to-sqlite"
+  ],
+  "sideEffects": false,
   "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    },
+    ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
   "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
+    "dist"
   ],
-  "sideEffects": false,
-  "devDependencies": {
-    "@changesets/cli": "^2.29.8",
-    "@stylistic/eslint-plugin": "^5.6.1",
-    "@typescript-eslint/eslint-plugin": "^8.51.0",
-    "@typescript-eslint/parser": "^8.51.0",
-    "@vitest/ui": "^4.0.16",
-    "db0": "^0.3.4",
-    "eslint": "^9.39.2",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
-  },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": ">=24.4.0"
+    "node": ">=22.0.0",
+    "pnpm": ">=11.0.0"
   },
   "dependencies": {
-    "zod": "^4.3.5"
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@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.8.1",
+    "relizy": "^1.4.9",
+    "tsdown": "^0.22.14",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
   },
-  "keywords": [
-    "zod",
-    "sqlite",
-    "database",
-    "schema",
-    "validation",
-    "zod-to-sqlite"
-  ],
   "scripts": {
-    "build": "pnpm clean && tsup",
-    "dev": "tsup --watch",
-    "test": "vitest",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest --watch --ui",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "ci:release": "pnpm build && pnpm dlx @changesets/cli publish",
-    "ci:version": "pnpm dlx @changesets/cli version && pnpm install --no-frozen-lockfile"
+    "lint": "eslint . --fix",
+    "ready": "pnpm install && pnpm lint && pnpm typecheck && pnpm test && pnpm build"
   }
 }

package/dist/index.cjs

@@ -1,255 +0,0 @@
-'use strict';
-
-require('zod/v4/core');
-var zod = require('zod');
-
-// src/utils/format-check-constraint.ts
-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;
-  const zodType = definition.type;
-  switch (zodType) {
-    case "enum": {
-      const entries = definition.entries;
-      const values = Object.values(entries);
-      const quotedValues = values.map((value) => `'${String(value).replace(/'/g, "''")}'`).join(", ");
-      return `CHECK(${name} IN (${quotedValues}))`;
-    }
-    case "literal": {
-      const values = definition.values;
-      if (values.length === 1) {
-        const value = values[0];
-        if (typeof value === "string") {
-          return `CHECK(${name} = '${value.replace(/'/g, "''")}')`;
-        }
-        return `CHECK(${name} = ${value})`;
-      }
-      const quotedValues = values.map((value) => {
-        if (typeof value === "string") {
-          return `'${value.replace(/'/g, "''")}'`;
-        }
-        return String(value);
-      }).join(", ");
-      return `CHECK(${name} IN (${quotedValues}))`;
-    }
-    case "union": {
-      const options = definition.options;
-      const allAreLiterals = options.every((option) => option._zod.def.type === "literal");
-      if (!allAreLiterals) return null;
-      const values = [];
-      for (const option of options) {
-        values.push(...option._zod.def.values);
-      }
-      const quotedValues = values.map((value) => {
-        if (typeof value === "string") {
-          return `'${value.replace(/'/g, "''")}'`;
-        }
-        return String(value);
-      }).join(", ");
-      return `CHECK(${name} IN (${quotedValues}))`;
-    }
-    case "number": {
-      const checks = definition.checks;
-      const constraints = [];
-      if (!checks) return null;
-      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}`);
-            break;
-        }
-      }
-      return constraints.length > 0 ? `CHECK(${constraints.join(" AND ")})` : null;
-    }
-    case "string": {
-      const checks = definition.checks;
-      const constraints = [];
-      if (!checks) return null;
-      for (const check of checks) {
-        const checkParameters = check._zod.def.check;
-        const checkDefinition = check._zod.def;
-        switch (checkParameters) {
-          case "min_length":
-            constraints.push(`length(${name}) >= ${checkDefinition.minimum}`);
-            break;
-          case "max_length":
-            constraints.push(`length(${name}) <= ${checkDefinition.maximum}`);
-            break;
-          case "length_equals":
-            constraints.push(`length(${name}) = ${checkDefinition.length}`);
-            break;
-        }
-      }
-      return constraints.length > 0 ? `CHECK(${constraints.join(" AND ")})` : null;
-    }
-    default:
-      return null;
-  }
-}
-
-// src/utils/format-default-value.ts
-function formatDefaultValue(value, SQLiteType) {
-  switch (SQLiteType) {
-    case "TEXT":
-      return `DEFAULT '${String(value).replace(/'/g, "''")}'`;
-    case "INTEGER":
-    case "REAL":
-      return `DEFAULT ${Number(value)}`;
-    case "BOOLEAN":
-      return `DEFAULT ${Boolean(value) ? 1 : 0}`;
-    case "NULL":
-      return "DEFAULT NULL";
-    default:
-      return `DEFAULT '${value}'`;
-  }
-}
-function mapZodTypeToSQLite(zodType, schema) {
-  switch (zodType) {
-    case "string": {
-      const format = schema._zod.def.format;
-      switch (format) {
-        case "date":
-          return "DATE";
-        case "datetime":
-          return "DATETIME";
-        case "duration":
-          return "INTEGER";
-        default:
-          return "TEXT";
-      }
-    }
-    case "date":
-      return "DATE";
-    case "enum":
-    case "literal":
-    case "template_literal":
-    case "array":
-    case "object":
-      return "TEXT";
-    case "number": {
-      const format = schema._zod.def.format;
-      switch (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";
-  }
-}
-
-// src/utils/zod-to-sqlite.ts
-function zodToSQLite(schema) {
-  let nullable = false;
-  let defaultValue = void 0;
-  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 { SQLiteType, nullable, defaultValue, schema };
-}
-
-// src/core/column-definitions.ts
-function buildColumnDefinition(column) {
-  const { name, schema, unique, references } = column;
-  const { SQLiteType, nullable, defaultValue } = 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 { table, column: refColumn, onDelete, onUpdate } = references;
-    parts.push(`REFERENCES ${table}(${refColumn})`);
-    if (onDelete) parts.push(`ON DELETE ${onDelete}`);
-    if (onUpdate) parts.push(`ON UPDATE ${onUpdate}`);
-  }
-  return parts.join(" ");
-}
-
-// src/core/index-statements.ts
-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};`;
-  });
-}
-
-// src/core/primary-key-constraint.ts
-function buildPrimaryKeyConstraint(primaryKeys) {
-  if (primaryKeys.length === 0) return "";
-  return `PRIMARY KEY (${primaryKeys.join(", ")})`;
-}
-function buildZodSchema(columns) {
-  const schemaShape = {};
-  for (const column of columns) {
-    schemaShape[column.name] = column.schema;
-  }
-  return zod.z.object(schemaShape);
-}
-
-// src/core/table.ts
-function createTable(config) {
-  const { name, columns, primaryKeys, indexes } = config;
-  const columnDefs = columns.map(buildColumnDefinition);
-  const primaryKeyConstraint = buildPrimaryKeyConstraint(primaryKeys);
-  const tableElements = [...columnDefs, primaryKeyConstraint].filter(Boolean);
-  const createTableSQL = `CREATE TABLE ${name} (
-  ${tableElements.join(",\n  ")}
-);`;
-  const createIndexesSQL = buildIndexStatements(name, indexes);
-  const zodSchema = buildZodSchema(columns);
-  return {
-    table: createTableSQL,
-    indexes: createIndexesSQL,
-    schema: zodSchema
-  };
-}
-
-exports.createTable = createTable;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map