sqlite-zod-orm 3.17.0 → 3.19.0

package/dist/index.js

@@ -4429,6 +4429,26 @@ class QueryBuilder {
     this.iqo.rawWheres.push({ sql, params });
     return this;
   }
+  whereIn(column, values) {
+    if (Array.isArray(values)) {
+      const placeholders = values.map(() => "?").join(", ");
+      this.iqo.rawWheres.push({ sql: `"${column}" IN (${placeholders})`, params: values });
+    } else {
+      const inner = compileIQO(values.tableName, values.iqo);
+      this.iqo.rawWheres.push({ sql: `"${column}" IN (${inner.sql})`, params: inner.params });
+    }
+    return this;
+  }
+  whereNotIn(column, values) {
+    if (Array.isArray(values)) {
+      const placeholders = values.map(() => "?").join(", ");
+      this.iqo.rawWheres.push({ sql: `"${column}" NOT IN (${placeholders})`, params: values });
+    } else {
+      const inner = compileIQO(values.tableName, values.iqo);
+      this.iqo.rawWheres.push({ sql: `"${column}" NOT IN (${inner.sql})`, params: inner.params });
+    }
+    return this;
+  }
   with(...relations) {
     this.iqo.includes.push(...relations);
     return this;
@@ -4552,6 +4572,34 @@ class QueryBuilder {
     const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT ${groupCols}, COUNT(*) as count FROM`);
     return this.executor(aggSql, params, true);
   }
+  updateAll(data) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const whereMatch = selectSql.match(/WHERE (.+?)(?:\s+ORDER|\s+LIMIT|\s+GROUP|\s+HAVING|$)/s);
+    const wherePart = whereMatch ? whereMatch[1] : "1=1";
+    const setClauses = [];
+    const setParams = [];
+    for (const [col, val] of Object.entries(data)) {
+      setClauses.push(`"${col}" = ?`);
+      if (val !== null && val !== undefined && typeof val === "object" && !(val instanceof Buffer) && !(val instanceof Date)) {
+        setParams.push(JSON.stringify(val));
+      } else {
+        setParams.push(val);
+      }
+    }
+    const updateSql = `UPDATE "${this.tableName}" SET ${setClauses.join(", ")} WHERE ${wherePart}`;
+    this.executor(updateSql, [...setParams, ...params], true);
+    const result = this.executor(`SELECT changes() as c`, [], true);
+    return result[0]?.c ?? 0;
+  }
+  deleteAll() {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const whereMatch = selectSql.match(/WHERE (.+?)(?:\s+ORDER|\s+LIMIT|\s+GROUP|\s+HAVING|$)/s);
+    const wherePart = whereMatch ? whereMatch[1] : "1=1";
+    const deleteSql = `DELETE FROM "${this.tableName}" WHERE ${wherePart}`;
+    this.executor(deleteSql, params, true);
+    const result = this.executor(`SELECT changes() as c`, [], true);
+    return result[0]?.c ?? 0;
+  }
   then(onfulfilled, onrejected) {
     try {
       const result = this.all();
@@ -5483,6 +5531,38 @@ class _Database {
   seed(fixtures) {
     this.load(fixtures, { append: true });
   }
+  diff() {
+    const result = {};
+    const systemCols = new Set(["id", "createdAt", "updatedAt", "deletedAt"]);
+    for (const [tableName, schema] of Object.entries(this.schemas)) {
+      const schemaFields = getStorableFields(schema);
+      const schemaColMap = new Map(schemaFields.map((f) => [f.name, zodTypeToSqlType(f.type)]));
+      const liveColumns = this.columns(tableName);
+      const liveColMap = new Map(liveColumns.map((c) => [c.name, c.type]));
+      const added = [];
+      const removed = [];
+      const typeChanged = [];
+      for (const [col, expectedType] of schemaColMap) {
+        if (!liveColMap.has(col)) {
+          added.push(col);
+        } else {
+          const actualType = liveColMap.get(col);
+          if (actualType !== expectedType) {
+            typeChanged.push({ column: col, expected: expectedType, actual: actualType });
+          }
+        }
+      }
+      for (const col of liveColMap.keys()) {
+        if (!systemCols.has(col) && !schemaColMap.has(col)) {
+          removed.push(col);
+        }
+      }
+      if (added.length > 0 || removed.length > 0 || typeChanged.length > 0) {
+        result[tableName] = { added, removed, typeChanged };
+      }
+    }
+    return result;
+  }
 }
 var Database = _Database;
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.17.0",
+  "version": "3.19.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

@@ -231,6 +231,39 @@ export class QueryBuilder<T extends Record<string, any>, TResult extends Record<
         return this;
     }
 
+    /**
+     * Filter by column value being in a list or subquery.
+     * ```ts
+     * db.users.select().whereIn('id', [1, 2, 3]).all()
+     * db.users.select().whereIn('id', db.orders.select('userId')).all()
+     * ```
+     */
+    whereIn(column: keyof T & string, values: any[] | QueryBuilder<any, any>): this {
+        if (Array.isArray(values)) {
+            const placeholders = values.map(() => '?').join(', ');
+            this.iqo.rawWheres.push({ sql: `"${column}" IN (${placeholders})`, params: values });
+        } else {
+            // Subquery: compile the inner QueryBuilder's IQO
+            const inner = compileIQO((values as any).tableName, (values as any).iqo);
+            this.iqo.rawWheres.push({ sql: `"${column}" IN (${inner.sql})`, params: inner.params });
+        }
+        return this;
+    }
+
+    /**
+     * Filter by column value NOT being in a list or subquery.
+     */
+    whereNotIn(column: keyof T & string, values: any[] | QueryBuilder<any, any>): this {
+        if (Array.isArray(values)) {
+            const placeholders = values.map(() => '?').join(', ');
+            this.iqo.rawWheres.push({ sql: `"${column}" NOT IN (${placeholders})`, params: values });
+        } else {
+            const inner = compileIQO((values as any).tableName, (values as any).iqo);
+            this.iqo.rawWheres.push({ sql: `"${column}" NOT IN (${inner.sql})`, params: inner.params });
+        }
+        return this;
+    }
+
     /**
      * Eagerly load a related entity and attach as an array property.
      *
@@ -432,6 +465,56 @@ export class QueryBuilder<T extends Record<string, any>, TResult extends Record<
         return this.executor(aggSql, params, true) as any;
     }
 
+    // ---------- Batch Mutations ----------
+
+    /**
+     * Update all rows matching the current query's WHERE conditions.
+     * Returns the number of affected rows.
+     * ```ts
+     * db.users.select().where({ role: 'guest' }).updateAll({ role: 'member' })
+     * ```
+     */
+    updateAll(data: Partial<T>): number {
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        // Extract WHERE clause from compiled SELECT
+        const whereMatch = selectSql.match(/WHERE (.+?)(?:\s+ORDER|\s+LIMIT|\s+GROUP|\s+HAVING|$)/s);
+        const wherePart = whereMatch ? whereMatch[1] : '1=1';
+
+        const setClauses: string[] = [];
+        const setParams: any[] = [];
+        for (const [col, val] of Object.entries(data)) {
+            setClauses.push(`"${col}" = ?`);
+            if (val !== null && val !== undefined && typeof val === 'object' && !(val instanceof Buffer) && !(val instanceof Date)) {
+                setParams.push(JSON.stringify(val));
+            } else {
+                setParams.push(val);
+            }
+        }
+
+        const updateSql = `UPDATE "${this.tableName}" SET ${setClauses.join(', ')} WHERE ${wherePart}`;
+        this.executor(updateSql, [...setParams, ...params], true);
+        // Return affected rows via changes()
+        const result = this.executor(`SELECT changes() as c`, [], true);
+        return (result[0] as any)?.c ?? 0;
+    }
+
+    /**
+     * Delete all rows matching the current query's WHERE conditions.
+     * Returns the number of deleted rows.
+     * ```ts
+     * db.users.select().where({ role: 'guest' }).deleteAll()
+     * ```
+     */
+    deleteAll(): number {
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        const whereMatch = selectSql.match(/WHERE (.+?)(?:\s+ORDER|\s+LIMIT|\s+GROUP|\s+HAVING|$)/s);
+        const wherePart = whereMatch ? whereMatch[1] : '1=1';
+
+        const deleteSql = `DELETE FROM "${this.tableName}" WHERE ${wherePart}`;
+        this.executor(deleteSql, params, true);
+        const result = this.executor(`SELECT changes() as c`, [], true);
+        return (result[0] as any)?.c ?? 0;
+    }
 
 
     // ---------- Thenable (async/await support) ----------

package/src/database.ts

@@ -473,6 +473,56 @@ class _Database<Schemas extends SchemaMap> {
     public seed(fixtures: Record<string, Record<string, any>[]>): void {
         this.load(fixtures, { append: true });
     }
+
+    // =========================================================================
+    // Schema Diffing
+    // =========================================================================
+
+    /**
+     * Compare Zod schemas against the live SQLite table structure.
+     * Returns a diff object per table: { added, removed, typeChanged }.
+     */
+    public diff(): Record<string, { added: string[]; removed: string[]; typeChanged: { column: string; expected: string; actual: string }[] }> {
+        const result: Record<string, { added: string[]; removed: string[]; typeChanged: { column: string; expected: string; actual: string }[] }> = {};
+        const systemCols = new Set(['id', 'createdAt', 'updatedAt', 'deletedAt']);
+
+        for (const [tableName, schema] of Object.entries(this.schemas)) {
+            const schemaFields = getStorableFields(schema);
+            const schemaColMap = new Map(schemaFields.map(f => [f.name, zodTypeToSqlType(f.type)]));
+
+            const liveColumns = this.columns(tableName);
+            const liveColMap = new Map(liveColumns.map(c => [c.name, c.type]));
+
+            const added: string[] = [];
+            const removed: string[] = [];
+            const typeChanged: { column: string; expected: string; actual: string }[] = [];
+
+            // Columns in schema but not in live DB
+            for (const [col, expectedType] of schemaColMap) {
+                if (!liveColMap.has(col)) {
+                    added.push(col);
+                } else {
+                    const actualType = liveColMap.get(col)!;
+                    if (actualType !== expectedType) {
+                        typeChanged.push({ column: col, expected: expectedType, actual: actualType });
+                    }
+                }
+            }
+
+            // Columns in live DB but not in schema (excluding system columns)
+            for (const col of liveColMap.keys()) {
+                if (!systemCols.has(col) && !schemaColMap.has(col)) {
+                    removed.push(col);
+                }
+            }
+
+            if (added.length > 0 || removed.length > 0 || typeChanged.length > 0) {
+                result[tableName] = { added, removed, typeChanged };
+            }
+        }
+
+        return result;
+    }
 }
 
 // =============================================================================