sqlite-zod-orm 3.10.0 → 3.12.0

package/dist/index.js

@@ -4149,7 +4149,9 @@ var OPERATOR_MAP = {
   $in: "IN",
   $like: "LIKE",
   $notIn: "NOT IN",
-  $between: "BETWEEN"
+  $between: "BETWEEN",
+  $isNull: "IS NULL",
+  $isNotNull: "IS NOT NULL"
 };
 function transformValueForStorage(value) {
   if (value instanceof Date)
@@ -4173,7 +4175,7 @@ function compileIQO(tableName, iqo) {
       selectParts.push(`${j.table}.*`);
     }
   }
-  let sql = `SELECT ${selectParts.join(", ")} FROM ${tableName}`;
+  let sql = `SELECT ${iqo.distinct ? "DISTINCT " : ""}${selectParts.join(", ")} FROM ${tableName}`;
   for (const j of iqo.joins) {
     sql += ` JOIN ${j.table} ON ${tableName}.${j.fromCol} = ${j.table}.${j.toCol}`;
   }
@@ -4206,6 +4208,10 @@ function compileIQO(tableName, iqo) {
         const [min, max] = w.value;
         whereParts.push(`${qualify(w.field)} BETWEEN ? AND ?`);
         params.push(transformValueForStorage(min), transformValueForStorage(max));
+      } else if (w.operator === "IS NULL") {
+        whereParts.push(`${qualify(w.field)} IS NULL`);
+      } else if (w.operator === "IS NOT NULL") {
+        whereParts.push(`${qualify(w.field)} IS NOT NULL`);
       } else {
         whereParts.push(`${qualify(w.field)} ${w.operator} ?`);
         params.push(transformValueForStorage(w.value));
@@ -4241,6 +4247,22 @@ function compileIQO(tableName, iqo) {
   if (iqo.groupBy.length > 0) {
     sql += ` GROUP BY ${iqo.groupBy.join(", ")}`;
   }
+  if (iqo.having && iqo.having.length > 0) {
+    const havingParts = [];
+    for (const h of iqo.having) {
+      if (h.operator === "IS NULL") {
+        havingParts.push(`${h.field} IS NULL`);
+      } else if (h.operator === "IS NOT NULL") {
+        havingParts.push(`${h.field} IS NOT NULL`);
+      } else {
+        havingParts.push(`${h.field} ${h.operator} ?`);
+        params.push(transformValueForStorage(h.value));
+      }
+    }
+    if (havingParts.length > 0) {
+      sql += ` HAVING ${havingParts.join(" AND ")}`;
+    }
+  }
   if (iqo.orderBy.length > 0) {
     const parts = iqo.orderBy.map((o) => `${o.field} ${o.direction.toUpperCase()}`);
     sql += ` ORDER BY ${parts.join(", ")}`;
@@ -4274,11 +4296,13 @@ class QueryBuilder {
       whereAST: null,
       joins: [],
       groupBy: [],
+      having: [],
       limit: null,
       offset: null,
       orderBy: [],
       includes: [],
-      raw: false
+      raw: false,
+      distinct: false
     };
   }
   select(...cols) {
@@ -4433,6 +4457,66 @@ class QueryBuilder {
     this.iqo.groupBy.push(...fields);
     return this;
   }
+  distinct() {
+    this.iqo.distinct = true;
+    return this;
+  }
+  withTrashed() {
+    this.iqo.wheres = this.iqo.wheres.filter((w) => !(w.field === "deletedAt" && w.operator === "IS NULL"));
+    return this;
+  }
+  onlyTrashed() {
+    this.iqo.wheres = this.iqo.wheres.filter((w) => !(w.field === "deletedAt" && w.operator === "IS NULL"));
+    this.iqo.wheres.push({ field: "deletedAt", operator: "IS NOT NULL", value: null });
+    return this;
+  }
+  having(conditions) {
+    for (const [field, value] of Object.entries(conditions)) {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        for (const [opKey, operand] of Object.entries(value)) {
+          const sqlOp = OPERATOR_MAP[opKey];
+          if (!sqlOp)
+            throw new Error(`Unsupported having operator: '${opKey}'`);
+          this.iqo.having.push({ field, operator: sqlOp, value: operand });
+        }
+      } else {
+        this.iqo.having.push({ field, operator: "=", value });
+      }
+    }
+    return this;
+  }
+  sum(field) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT COALESCE(SUM("${field}"), 0) as val FROM`);
+    const results = this.executor(aggSql, params, true);
+    return results[0]?.val ?? 0;
+  }
+  avg(field) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT AVG("${field}") as val FROM`);
+    const results = this.executor(aggSql, params, true);
+    return results[0]?.val ?? 0;
+  }
+  min(field) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT MIN("${field}") as val FROM`);
+    const results = this.executor(aggSql, params, true);
+    return results[0]?.val ?? null;
+  }
+  max(field) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT MAX("${field}") as val FROM`);
+    const results = this.executor(aggSql, params, true);
+    return results[0]?.val ?? null;
+  }
+  paginate(page = 1, perPage = 20) {
+    const total = this.count();
+    const pages = Math.ceil(total / perPage);
+    this.iqo.limit = perPage;
+    this.iqo.offset = (page - 1) * perPage;
+    const data = this.all();
+    return { data, total, page, perPage, pages };
+  }
   then(onfulfilled, onrejected) {
     try {
       const result = this.all();
@@ -4638,6 +4722,8 @@ function executeProxyQuery(schemas, callback, executor) {
 function createQueryBuilder(ctx, entityName, initialCols) {
   const schema = ctx.schemas[entityName];
   const executor = (sql, params, raw) => {
+    if (ctx.debug)
+      console.log("[satidb]", sql, params);
     const rows = ctx.db.query(sql).all(...params);
     if (raw)
       return rows;
@@ -4707,6 +4793,9 @@ function createQueryBuilder(ctx, entityName, initialCols) {
   const builder = new QueryBuilder(entityName, executor, singleExecutor, joinResolver, conditionResolver, eagerLoader);
   if (initialCols.length > 0)
     builder.select(...initialCols);
+  if (ctx.softDeletes) {
+    builder.where({ deletedAt: { $isNull: true } });
+  }
   return builder;
 }
 
@@ -4771,6 +4860,14 @@ function buildWhereClause(conditions, tablePrefix) {
         values.push(transformForStorage({ v: operand[0] }).v, transformForStorage({ v: operand[1] }).v);
         continue;
       }
+      if (operator === "$isNull") {
+        parts.push(`${fieldName} IS NULL`);
+        continue;
+      }
+      if (operator === "$isNotNull") {
+        parts.push(`${fieldName} IS NOT NULL`);
+        continue;
+      }
       const sqlOp = { $gt: ">", $gte: ">=", $lt: "<", $lte: "<=", $ne: "!=" }[operator];
       if (!sqlOp)
         throw new Error(`Unsupported operator '${operator}' on '${key}'`);
@@ -4807,9 +4904,16 @@ function insert(ctx, entityName, data) {
   const schema = ctx.schemas[entityName];
   const validatedData = asZodObject(schema).passthrough().parse(data);
   const transformed = transformForStorage(validatedData);
+  if (ctx.timestamps) {
+    const now = new Date().toISOString();
+    transformed.createdAt = now;
+    transformed.updatedAt = now;
+  }
   const columns = Object.keys(transformed);
   const quotedCols = columns.map((c) => `"${c}"`);
   const sql = columns.length === 0 ? `INSERT INTO "${entityName}" DEFAULT VALUES` : `INSERT INTO "${entityName}" (${quotedCols.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
+  if (ctx.debug)
+    console.log("[satidb]", sql, Object.values(transformed));
   const result = ctx.db.query(sql).run(...Object.values(transformed));
   const newEntity = getById(ctx, entityName, result.lastInsertRowid);
   if (!newEntity)
@@ -4820,10 +4924,16 @@ function update(ctx, entityName, id, data) {
   const schema = ctx.schemas[entityName];
   const validatedData = asZodObject(schema).partial().parse(data);
   const transformed = transformForStorage(validatedData);
-  if (Object.keys(transformed).length === 0)
+  if (Object.keys(transformed).length === 0 && !ctx.timestamps)
     return getById(ctx, entityName, id);
+  if (ctx.timestamps) {
+    transformed.updatedAt = new Date().toISOString();
+  }
   const setClause = Object.keys(transformed).map((key) => `"${key}" = ?`).join(", ");
-  ctx.db.query(`UPDATE "${entityName}" SET ${setClause} WHERE id = ?`).run(...Object.values(transformed), id);
+  const sql = `UPDATE "${entityName}" SET ${setClause} WHERE id = ?`;
+  if (ctx.debug)
+    console.log("[satidb]", sql, [...Object.values(transformed), id]);
+  ctx.db.query(sql).run(...Object.values(transformed), id);
   return getById(ctx, entityName, id);
 }
 function updateWhere(ctx, entityName, data, conditions) {
@@ -4870,7 +4980,18 @@ function deleteWhere(ctx, entityName, conditions) {
   const { clause, values } = ctx.buildWhereClause(conditions);
   if (!clause)
     throw new Error("delete().where() requires at least one condition");
-  const result = ctx.db.query(`DELETE FROM "${entityName}" ${clause}`).run(...values);
+  if (ctx.softDeletes) {
+    const now = new Date().toISOString();
+    const sql2 = `UPDATE "${entityName}" SET "deletedAt" = ? ${clause}`;
+    if (ctx.debug)
+      console.log("[satidb]", sql2, [now, ...values]);
+    const result2 = ctx.db.query(sql2).run(now, ...values);
+    return result2.changes ?? 0;
+  }
+  const sql = `DELETE FROM "${entityName}" ${clause}`;
+  if (ctx.debug)
+    console.log("[satidb]", sql, values);
+  const result = ctx.db.query(sql).run(...values);
   return result.changes ?? 0;
 }
 function createDeleteBuilder(ctx, entityName) {
@@ -4894,6 +5015,11 @@ function insertMany(ctx, entityName, rows) {
     for (const data of rows) {
       const validatedData = zodSchema.parse(data);
       const transformed = transformForStorage(validatedData);
+      if (ctx.timestamps) {
+        const now = new Date().toISOString();
+        transformed.createdAt = now;
+        transformed.updatedAt = now;
+      }
       const columns = Object.keys(transformed);
       const quotedCols = columns.map((c) => `"${c}"`);
       const sql = columns.length === 0 ? `INSERT INTO "${entityName}" DEFAULT VALUES` : `INSERT INTO "${entityName}" (${quotedCols.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
@@ -4944,6 +5070,9 @@ function attachMethods(ctx, entityName, entity) {
 class _Database {
   db;
   _reactive;
+  _timestamps;
+  _softDeletes;
+  _debug;
   schemas;
   relationships;
   options;
@@ -4959,6 +5088,9 @@ class _Database {
     this.schemas = schemas;
     this.options = options;
     this._reactive = options.reactive !== false;
+    this._timestamps = options.timestamps === true;
+    this._softDeletes = options.softDeletes === true;
+    this._debug = options.debug === true;
     this._pollInterval = options.pollInterval ?? 100;
     this.relationships = options.relations ? parseRelationsConfig(options.relations, schemas) : [];
     this._ctx = {
@@ -4966,7 +5098,10 @@ class _Database {
       schemas: this.schemas,
       relationships: this.relationships,
       attachMethods: (name, entity) => attachMethods(this._ctx, name, entity),
-      buildWhereClause: (conds, prefix) => buildWhereClause(conds, prefix)
+      buildWhereClause: (conds, prefix) => buildWhereClause(conds, prefix),
+      debug: this._debug,
+      timestamps: this._timestamps,
+      softDeletes: this._softDeletes
     };
     this.initializeTables();
     if (this._reactive)
@@ -4974,6 +5109,8 @@ class _Database {
     this.runMigrations();
     if (options.indexes)
       this.createIndexes(options.indexes);
+    if (options.unique)
+      this.createUniqueConstraints(options.unique);
     for (const entityName of Object.keys(schemas)) {
       const key = entityName;
       const accessor = {
@@ -4986,10 +5123,23 @@ class _Database {
         },
         upsert: (conditions, data) => upsert(this._ctx, entityName, data, conditions),
         delete: (id) => {
-          if (typeof id === "number")
+          if (typeof id === "number") {
+            if (this._softDeletes) {
+              const now = new Date().toISOString();
+              this.db.query(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`).run(now, id);
+              return;
+            }
             return deleteEntity(this._ctx, entityName, id);
+          }
           return createDeleteBuilder(this._ctx, entityName);
         },
+        restore: (id) => {
+          if (!this._softDeletes)
+            throw new Error("restore() requires softDeletes: true");
+          if (this._debug)
+            console.log("[satidb]", `UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`, [id]);
+          this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
+        },
         select: (...cols) => createQueryBuilder(this._ctx, entityName, cols),
         on: (event, callback) => {
           return this._registerListener(entityName, event, callback);
@@ -5003,6 +5153,13 @@ class _Database {
     for (const [entityName, schema] of Object.entries(this.schemas)) {
       const storableFields = getStorableFields(schema);
       const columnDefs = storableFields.map((f) => `"${f.name}" ${zodTypeToSqlType(f.type)}`);
+      if (this._timestamps) {
+        columnDefs.push('"createdAt" TEXT');
+        columnDefs.push('"updatedAt" TEXT');
+      }
+      if (this._softDeletes) {
+        columnDefs.push('"deletedAt" TEXT');
+      }
       const constraints = [];
       const belongsToRels = this.relationships.filter((rel) => rel.type === "belongs-to" && rel.from === entityName);
       for (const rel of belongsToRels) {
@@ -5062,6 +5219,14 @@ class _Database {
       }
     }
   }
+  createUniqueConstraints(unique) {
+    for (const [tableName, groups] of Object.entries(unique)) {
+      for (const cols of groups) {
+        const idxName = `uq_${tableName}_${cols.join("_")}`;
+        this.db.run(`CREATE UNIQUE INDEX IF NOT EXISTS "${idxName}" ON "${tableName}" (${cols.map((c) => `"${c}"`).join(", ")})`);
+      }
+    }
+  }
   _registerListener(table, event, callback) {
     if (!this._reactive) {
       throw new Error("Change listeners are disabled. Set { reactive: true } (or omit it) in Database options to enable .on().");
@@ -5117,7 +5282,7 @@ class _Database {
       }
       this._changeWatermark = change.id;
     }
-    this.db.run('DELETE FROM "_changes" WHERE id <= ?', this._changeWatermark);
+    this.db.query('DELETE FROM "_changes" WHERE id <= ?').run(this._changeWatermark);
   }
   transaction(callback) {
     return this.db.transaction(callback)();
@@ -5127,7 +5292,27 @@ class _Database {
     this.db.close();
   }
   query(callback) {
-    return executeProxyQuery(this.schemas, callback, (sql, params) => this.db.query(sql).all(...params));
+    return executeProxyQuery(this.schemas, callback, (sql, params) => {
+      if (this._debug)
+        console.log("[satidb]", sql, params);
+      return this.db.query(sql).all(...params);
+    });
+  }
+  raw(sql, ...params) {
+    if (this._debug)
+      console.log("[satidb]", sql, params);
+    return this.db.query(sql).all(...params);
+  }
+  exec(sql, ...params) {
+    if (this._debug)
+      console.log("[satidb]", sql, params);
+    this.db.run(sql, ...params);
+  }
+  tables() {
+    return Object.keys(this.schemas);
+  }
+  columns(tableName) {
+    return this.db.query(`PRAGMA table_info("${tableName}")`).all();
   }
 }
 var Database = _Database;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.10.0",
+  "version": "3.12.0",
   "description": "Type-safe SQLite ORM for Bun — Zod schemas, fluent queries, auto relationships, zero SQL",
   "type": "module",
   "main": "./dist/index.js",

package/src/builder.ts

@@ -57,11 +57,13 @@ export class QueryBuilder<T extends Record<string, any>> {
             whereAST: null,
             joins: [],
             groupBy: [],
+            having: [],
             limit: null,
             offset: null,
             orderBy: [],
             includes: [],
             raw: false,
+            distinct: false,
         };
     }
 
@@ -293,6 +295,105 @@ export class QueryBuilder<T extends Record<string, any>> {
         return this;
     }
 
+    /** Return only distinct rows. */
+    distinct(): this {
+        this.iqo.distinct = true;
+        return this;
+    }
+
+    /**
+     * Include soft-deleted rows in query results.
+     * Only relevant when `softDeletes: true` is set in Database options.
+     */
+    withTrashed(): this {
+        // Remove the auto-injected `deletedAt IS NULL` filter
+        this.iqo.wheres = this.iqo.wheres.filter(
+            w => !(w.field === 'deletedAt' && w.operator === 'IS NULL')
+        );
+        return this;
+    }
+
+    /**
+     * Return only soft-deleted rows.
+     * Only relevant when `softDeletes: true` is set in Database options.
+     */
+    onlyTrashed(): this {
+        // Remove the auto-injected `deletedAt IS NULL` and add `deletedAt IS NOT NULL`
+        this.iqo.wheres = this.iqo.wheres.filter(
+            w => !(w.field === 'deletedAt' && w.operator === 'IS NULL')
+        );
+        this.iqo.wheres.push({ field: 'deletedAt', operator: 'IS NOT NULL', value: null });
+        return this;
+    }
+
+    /**
+     * Add HAVING conditions (used after groupBy for aggregate filtering).
+     *
+     * ```ts
+     * db.orders.select('user_id').groupBy('user_id')
+     *   .having({ 'COUNT(*)': { $gt: 5 } })
+     *   .raw().all()
+     * ```
+     */
+    having(conditions: Record<string, any>): this {
+        for (const [field, value] of Object.entries(conditions)) {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                for (const [opKey, operand] of Object.entries(value)) {
+                    const sqlOp = OPERATOR_MAP[opKey as WhereOperator];
+                    if (!sqlOp) throw new Error(`Unsupported having operator: '${opKey}'`);
+                    this.iqo.having.push({ field, operator: sqlOp as WhereCondition['operator'], value: operand });
+                }
+            } else {
+                this.iqo.having.push({ field, operator: '=', value });
+            }
+        }
+        return this;
+    }
+
+    // ---------- Aggregate Methods ----------
+
+    /** Returns the SUM of a numeric column. */
+    sum(field: keyof T & string): number {
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT COALESCE(SUM("${field}"), 0) as val FROM`);
+        const results = this.executor(aggSql, params, true);
+        return (results[0] as any)?.val ?? 0;
+    }
+
+    /** Returns the AVG of a numeric column. */
+    avg(field: keyof T & string): number {
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT AVG("${field}") as val FROM`);
+        const results = this.executor(aggSql, params, true);
+        return (results[0] as any)?.val ?? 0;
+    }
+
+    /** Returns the MIN of a column. */
+    min(field: keyof T & string): number | string | null {
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT MIN("${field}") as val FROM`);
+        const results = this.executor(aggSql, params, true);
+        return (results[0] as any)?.val ?? null;
+    }
+
+    /** Returns the MAX of a column. */
+    max(field: keyof T & string): number | string | null {
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT MAX("${field}") as val FROM`);
+        const results = this.executor(aggSql, params, true);
+        return (results[0] as any)?.val ?? null;
+    }
+
+    /** Paginate results. Returns { data, total, page, perPage, pages }. */
+    paginate(page: number = 1, perPage: number = 20): { data: T[]; total: number; page: number; perPage: number; pages: number } {
+        const total = this.count();
+        const pages = Math.ceil(total / perPage);
+        this.iqo.limit = perPage;
+        this.iqo.offset = (page - 1) * perPage;
+        const data = this.all();
+        return { data, total, page, perPage, pages };
+    }
+
 
 
     // ---------- Thenable (async/await support) ----------

package/src/context.ts

@@ -22,4 +22,13 @@ export interface DatabaseContext {
 
     /** Build a WHERE clause from a conditions object. */
     buildWhereClause(conditions: Record<string, any>, tablePrefix?: string): { clause: string; values: any[] };
+
+    /** Whether to log SQL to console. */
+    debug: boolean;
+
+    /** Whether tables have createdAt/updatedAt columns. */
+    timestamps: boolean;
+
+    /** Whether soft deletes are enabled (deletedAt column). */
+    softDeletes: boolean;
 }

package/src/crud.ts

@@ -42,6 +42,14 @@ export function insert<T extends Record<string, any>>(ctx: DatabaseContext, enti
     const schema = ctx.schemas[entityName]!;
     const validatedData = asZodObject(schema).passthrough().parse(data);
     const transformed = transformForStorage(validatedData);
+
+    // Auto-inject timestamps
+    if (ctx.timestamps) {
+        const now = new Date().toISOString();
+        transformed.createdAt = now;
+        transformed.updatedAt = now;
+    }
+
     const columns = Object.keys(transformed);
 
     const quotedCols = columns.map(c => `"${c}"`);
@@ -49,6 +57,7 @@ export function insert<T extends Record<string, any>>(ctx: DatabaseContext, enti
         ? `INSERT INTO "${entityName}" DEFAULT VALUES`
         : `INSERT INTO "${entityName}" (${quotedCols.join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`;
 
+    if (ctx.debug) console.log('[satidb]', sql, Object.values(transformed));
     const result = ctx.db.query(sql).run(...Object.values(transformed));
     const newEntity = getById(ctx, entityName, result.lastInsertRowid as number);
     if (!newEntity) throw new Error('Failed to retrieve entity after insertion');
@@ -60,10 +69,17 @@ export function update<T extends Record<string, any>>(ctx: DatabaseContext, enti
     const schema = ctx.schemas[entityName]!;
     const validatedData = asZodObject(schema).partial().parse(data);
     const transformed = transformForStorage(validatedData);
-    if (Object.keys(transformed).length === 0) return getById(ctx, entityName, id);
+    if (Object.keys(transformed).length === 0 && !ctx.timestamps) return getById(ctx, entityName, id);
+
+    // Auto-update timestamp
+    if (ctx.timestamps) {
+        transformed.updatedAt = new Date().toISOString();
+    }
 
     const setClause = Object.keys(transformed).map(key => `"${key}" = ?`).join(', ');
-    ctx.db.query(`UPDATE "${entityName}" SET ${setClause} WHERE id = ?`).run(...Object.values(transformed), id);
+    const sql = `UPDATE "${entityName}" SET ${setClause} WHERE id = ?`;
+    if (ctx.debug) console.log('[satidb]', sql, [...Object.values(transformed), id]);
+    ctx.db.query(sql).run(...Object.values(transformed), id);
 
     return getById(ctx, entityName, id);
 }
@@ -118,11 +134,23 @@ export function deleteEntity(ctx: DatabaseContext, entityName: string, id: numbe
     ctx.db.query(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
 }
 
-/** Delete all rows matching the given conditions. Returns the number of rows deleted. */
+/** Delete all rows matching the given conditions. Returns the number of rows affected. */
 export function deleteWhere(ctx: DatabaseContext, entityName: string, conditions: Record<string, any>): number {
     const { clause, values } = ctx.buildWhereClause(conditions);
     if (!clause) throw new Error('delete().where() requires at least one condition');
-    const result = ctx.db.query(`DELETE FROM "${entityName}" ${clause}`).run(...values);
+
+    if (ctx.softDeletes) {
+        // Soft delete: set deletedAt instead of removing rows
+        const now = new Date().toISOString();
+        const sql = `UPDATE "${entityName}" SET "deletedAt" = ? ${clause}`;
+        if (ctx.debug) console.log('[satidb]', sql, [now, ...values]);
+        const result = ctx.db.query(sql).run(now, ...values);
+        return (result as any).changes ?? 0;
+    }
+
+    const sql = `DELETE FROM "${entityName}" ${clause}`;
+    if (ctx.debug) console.log('[satidb]', sql, values);
+    const result = ctx.db.query(sql).run(...values);
     return (result as any).changes ?? 0;
 }
 
@@ -147,6 +175,13 @@ export function insertMany<T extends Record<string, any>>(ctx: DatabaseContext,
         for (const data of rows) {
             const validatedData = zodSchema.parse(data);
             const transformed = transformForStorage(validatedData);
+
+            if (ctx.timestamps) {
+                const now = new Date().toISOString();
+                transformed.createdAt = now;
+                transformed.updatedAt = now;
+            }
+
             const columns = Object.keys(transformed);
             const quotedCols = columns.map(c => `"${c}"`);
             const sql = columns.length === 0