sqlite-zod-orm 3.12.0 → 3.13.0

package/dist/index.js

@@ -4517,6 +4517,15 @@ class QueryBuilder {
     const data = this.all();
     return { data, total, page, perPage, pages };
   }
+  countGrouped() {
+    if (this.iqo.groupBy.length === 0) {
+      throw new Error("countGrouped() requires at least one groupBy() call");
+    }
+    const groupCols = this.iqo.groupBy.map((c) => `"${c}"`).join(", ");
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT ${groupCols}, COUNT(*) as count FROM`);
+    return this.executor(aggSql, params, true);
+  }
   then(onfulfilled, onrejected) {
     try {
       const result = this.all();
@@ -4902,7 +4911,14 @@ function findMany(ctx, entityName, conditions = {}) {
 }
 function insert(ctx, entityName, data) {
   const schema = ctx.schemas[entityName];
-  const validatedData = asZodObject(schema).passthrough().parse(data);
+  let inputData = { ...data };
+  const hooks = ctx.hooks[entityName];
+  if (hooks?.beforeInsert) {
+    const result2 = hooks.beforeInsert(inputData);
+    if (result2)
+      inputData = result2;
+  }
+  const validatedData = asZodObject(schema).passthrough().parse(inputData);
   const transformed = transformForStorage(validatedData);
   if (ctx.timestamps) {
     const now = new Date().toISOString();
@@ -4918,11 +4934,20 @@ function insert(ctx, entityName, data) {
   const newEntity = getById(ctx, entityName, result.lastInsertRowid);
   if (!newEntity)
     throw new Error("Failed to retrieve entity after insertion");
+  if (hooks?.afterInsert)
+    hooks.afterInsert(newEntity);
   return newEntity;
 }
 function update(ctx, entityName, id, data) {
   const schema = ctx.schemas[entityName];
-  const validatedData = asZodObject(schema).partial().parse(data);
+  let inputData = { ...data };
+  const hooks = ctx.hooks[entityName];
+  if (hooks?.beforeUpdate) {
+    const result = hooks.beforeUpdate(inputData, id);
+    if (result)
+      inputData = result;
+  }
+  const validatedData = asZodObject(schema).partial().parse(inputData);
   const transformed = transformForStorage(validatedData);
   if (Object.keys(transformed).length === 0 && !ctx.timestamps)
     return getById(ctx, entityName, id);
@@ -4934,7 +4959,10 @@ function update(ctx, entityName, id, data) {
   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);
+  const updated = getById(ctx, entityName, id);
+  if (hooks?.afterUpdate && updated)
+    hooks.afterUpdate(updated);
+  return updated;
 }
 function updateWhere(ctx, entityName, data, conditions) {
   const schema = ctx.schemas[entityName];
@@ -4974,7 +5002,15 @@ function upsert(ctx, entityName, data, conditions = {}) {
   return insert(ctx, entityName, insertData);
 }
 function deleteEntity(ctx, entityName, id) {
+  const hooks = ctx.hooks[entityName];
+  if (hooks?.beforeDelete) {
+    const result = hooks.beforeDelete(id);
+    if (result === false)
+      return;
+  }
   ctx.db.query(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
+  if (hooks?.afterDelete)
+    hooks.afterDelete(id);
 }
 function deleteWhere(ctx, entityName, conditions) {
   const { clause, values } = ctx.buildWhereClause(conditions);
@@ -5010,10 +5046,17 @@ function insertMany(ctx, entityName, rows) {
     return [];
   const schema = ctx.schemas[entityName];
   const zodSchema = asZodObject(schema).passthrough();
+  const hooks = ctx.hooks[entityName];
   const txn = ctx.db.transaction(() => {
     const ids2 = [];
-    for (const data of rows) {
-      const validatedData = zodSchema.parse(data);
+    for (let data of rows) {
+      let inputData = { ...data };
+      if (hooks?.beforeInsert) {
+        const result2 = hooks.beforeInsert(inputData);
+        if (result2)
+          inputData = result2;
+      }
+      const validatedData = zodSchema.parse(inputData);
       const transformed = transformForStorage(validatedData);
       if (ctx.timestamps) {
         const now = new Date().toISOString();
@@ -5029,7 +5072,24 @@ function insertMany(ctx, entityName, rows) {
     return ids2;
   });
   const ids = txn();
-  return ids.map((id) => getById(ctx, entityName, id)).filter(Boolean);
+  const entities = ids.map((id) => getById(ctx, entityName, id)).filter(Boolean);
+  if (hooks?.afterInsert) {
+    for (const entity of entities)
+      hooks.afterInsert(entity);
+  }
+  return entities;
+}
+function upsertMany(ctx, entityName, rows, conditions = {}) {
+  if (rows.length === 0)
+    return [];
+  const txn = ctx.db.transaction(() => {
+    const results = [];
+    for (const data of rows) {
+      results.push(upsert(ctx, entityName, data, conditions));
+    }
+    return results;
+  });
+  return txn();
 }
 
 // src/entity.ts
@@ -5101,7 +5161,8 @@ class _Database {
       buildWhereClause: (conds, prefix) => buildWhereClause(conds, prefix),
       debug: this._debug,
       timestamps: this._timestamps,
-      softDeletes: this._softDeletes
+      softDeletes: this._softDeletes,
+      hooks: options.hooks ?? {}
     };
     this.initializeTables();
     if (this._reactive)
@@ -5122,11 +5183,20 @@ class _Database {
           return createUpdateBuilder(this._ctx, entityName, idOrData);
         },
         upsert: (conditions, data) => upsert(this._ctx, entityName, data, conditions),
+        upsertMany: (rows, conditions) => upsertMany(this._ctx, entityName, rows, conditions),
         delete: (id) => {
           if (typeof id === "number") {
+            const hooks = this._ctx.hooks[entityName];
+            if (hooks?.beforeDelete) {
+              const result = hooks.beforeDelete(id);
+              if (result === false)
+                return;
+            }
             if (this._softDeletes) {
               const now = new Date().toISOString();
               this.db.query(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`).run(now, id);
+              if (hooks?.afterDelete)
+                hooks.afterDelete(id);
               return;
             }
             return deleteEntity(this._ctx, entityName, id);

package/package.json

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

@@ -394,6 +394,28 @@ export class QueryBuilder<T extends Record<string, any>> {
         return { data, total, page, perPage, pages };
     }
 
+    /**
+     * Count rows per group. Must call `.groupBy()` first.
+     * Returns an array of objects with the grouped column(s) and a `count` field.
+     *
+     * ```ts
+     * db.users.select('role').groupBy('role').countGrouped()
+     * // → [{ role: 'admin', count: 5 }, { role: 'member', count: 12 }]
+     * ```
+     */
+    countGrouped(): (Record<string, any> & { count: number })[] {
+        if (this.iqo.groupBy.length === 0) {
+            throw new Error('countGrouped() requires at least one groupBy() call');
+        }
+        const groupCols = this.iqo.groupBy.map(c => `"${c}"`).join(', ');
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        const aggSql = selectSql.replace(
+            /^SELECT .+? FROM/,
+            `SELECT ${groupCols}, COUNT(*) as count FROM`
+        );
+        return this.executor(aggSql, params, true) as any;
+    }
+
 
 
     // ---------- Thenable (async/await support) ----------

package/src/context.ts

@@ -5,7 +5,7 @@
  * can access the Database's internals without importing the full class.
  */
 import type { Database as SqliteDatabase } from 'bun:sqlite';
-import type { SchemaMap, Relationship, AugmentedEntity } from './types';
+import type { SchemaMap, Relationship, AugmentedEntity, TableHooks } from './types';
 
 export interface DatabaseContext {
     /** The raw bun:sqlite Database handle. */
@@ -31,4 +31,7 @@ export interface DatabaseContext {
 
     /** Whether soft deletes are enabled (deletedAt column). */
     softDeletes: boolean;
+
+    /** Lifecycle hooks keyed by table name. */
+    hooks: Record<string, TableHooks>;
 }

package/src/crud.ts

@@ -40,7 +40,16 @@ export function findMany(ctx: DatabaseContext, entityName: string, conditions: R
 
 export function insert<T extends Record<string, any>>(ctx: DatabaseContext, entityName: string, data: Omit<T, 'id'>): AugmentedEntity<any> {
     const schema = ctx.schemas[entityName]!;
-    const validatedData = asZodObject(schema).passthrough().parse(data);
+    let inputData = { ...data } as Record<string, any>;
+
+    // beforeInsert hook — can transform data
+    const hooks = ctx.hooks[entityName];
+    if (hooks?.beforeInsert) {
+        const result = hooks.beforeInsert(inputData);
+        if (result) inputData = result;
+    }
+
+    const validatedData = asZodObject(schema).passthrough().parse(inputData);
     const transformed = transformForStorage(validatedData);
 
     // Auto-inject timestamps
@@ -62,12 +71,24 @@ export function insert<T extends Record<string, any>>(ctx: DatabaseContext, enti
     const newEntity = getById(ctx, entityName, result.lastInsertRowid as number);
     if (!newEntity) throw new Error('Failed to retrieve entity after insertion');
 
+    // afterInsert hook
+    if (hooks?.afterInsert) hooks.afterInsert(newEntity);
+
     return newEntity;
 }
 
 export function update<T extends Record<string, any>>(ctx: DatabaseContext, entityName: string, id: number, data: Partial<Omit<T, 'id'>>): AugmentedEntity<any> | null {
     const schema = ctx.schemas[entityName]!;
-    const validatedData = asZodObject(schema).partial().parse(data);
+    let inputData = { ...data } as Record<string, any>;
+
+    // beforeUpdate hook — can transform data
+    const hooks = ctx.hooks[entityName];
+    if (hooks?.beforeUpdate) {
+        const result = hooks.beforeUpdate(inputData, id);
+        if (result) inputData = result;
+    }
+
+    const validatedData = asZodObject(schema).partial().parse(inputData);
     const transformed = transformForStorage(validatedData);
     if (Object.keys(transformed).length === 0 && !ctx.timestamps) return getById(ctx, entityName, id);
 
@@ -81,7 +102,12 @@ export function update<T extends Record<string, any>>(ctx: DatabaseContext, enti
     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);
+    const updated = getById(ctx, entityName, id);
+
+    // afterUpdate hook
+    if (hooks?.afterUpdate && updated) hooks.afterUpdate(updated);
+
+    return updated;
 }
 
 export function updateWhere(ctx: DatabaseContext, entityName: string, data: Record<string, any>, conditions: Record<string, any>): number {
@@ -131,7 +157,17 @@ export function upsert<T extends Record<string, any>>(ctx: DatabaseContext, enti
 }
 
 export function deleteEntity(ctx: DatabaseContext, entityName: string, id: number): void {
+    // beforeDelete hook — return false to cancel
+    const hooks = ctx.hooks[entityName];
+    if (hooks?.beforeDelete) {
+        const result = hooks.beforeDelete(id);
+        if (result === false) return;
+    }
+
     ctx.db.query(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
+
+    // afterDelete hook
+    if (hooks?.afterDelete) hooks.afterDelete(id);
 }
 
 /** Delete all rows matching the given conditions. Returns the number of rows affected. */
@@ -169,11 +205,20 @@ export function insertMany<T extends Record<string, any>>(ctx: DatabaseContext,
     if (rows.length === 0) return [];
     const schema = ctx.schemas[entityName]!;
     const zodSchema = asZodObject(schema).passthrough();
+    const hooks = ctx.hooks[entityName];
 
     const txn = ctx.db.transaction(() => {
         const ids: number[] = [];
-        for (const data of rows) {
-            const validatedData = zodSchema.parse(data);
+        for (let data of rows) {
+            let inputData = { ...data } as Record<string, any>;
+
+            // beforeInsert hook
+            if (hooks?.beforeInsert) {
+                const result = hooks.beforeInsert(inputData);
+                if (result) inputData = result;
+            }
+
+            const validatedData = zodSchema.parse(inputData);
             const transformed = transformForStorage(validatedData);
 
             if (ctx.timestamps) {
@@ -194,5 +239,27 @@ export function insertMany<T extends Record<string, any>>(ctx: DatabaseContext,
     });
 
     const ids = txn();
-    return ids.map((id: number) => getById(ctx, entityName, id)!).filter(Boolean);
+    const entities = ids.map((id: number) => getById(ctx, entityName, id)!).filter(Boolean);
+
+    // afterInsert hooks
+    if (hooks?.afterInsert) {
+        for (const entity of entities) hooks.afterInsert(entity);
+    }
+
+    return entities;
+}
+
+/** Upsert multiple rows in a single transaction. */
+export function upsertMany<T extends Record<string, any>>(ctx: DatabaseContext, entityName: string, rows: any[], conditions: Record<string, any> = {}): AugmentedEntity<any>[] {
+    if (rows.length === 0) return [];
+
+    const txn = ctx.db.transaction(() => {
+        const results: AugmentedEntity<any>[] = [];
+        for (const data of rows) {
+            results.push(upsert(ctx, entityName, data, conditions));
+        }
+        return results;
+    });
+
+    return txn();
 }

package/src/database.ts

@@ -24,7 +24,7 @@ import type { DatabaseContext } from './context';
 import { buildWhereClause } from './helpers';
 import { attachMethods } from './entity';
 import {
-    insert, insertMany, update, upsert, deleteEntity, createDeleteBuilder,
+    insert, insertMany, update, upsert, upsertMany, deleteEntity, createDeleteBuilder,
     getById, getOne, findMany, updateWhere, createUpdateBuilder,
 } from './crud';
 
@@ -86,6 +86,7 @@ class _Database<Schemas extends SchemaMap> {
             debug: this._debug,
             timestamps: this._timestamps,
             softDeletes: this._softDeletes,
+            hooks: options.hooks ?? {},
         };
 
         this.initializeTables();
@@ -105,12 +106,20 @@ class _Database<Schemas extends SchemaMap> {
                     return createUpdateBuilder(this._ctx, entityName, idOrData);
                 },
                 upsert: (conditions, data) => upsert(this._ctx, entityName, data, conditions),
+                upsertMany: (rows: any[], conditions?: any) => upsertMany(this._ctx, entityName, rows, conditions),
                 delete: ((id?: any) => {
                     if (typeof id === 'number') {
+                        // beforeDelete hook — return false to cancel
+                        const hooks = this._ctx.hooks[entityName];
+                        if (hooks?.beforeDelete) {
+                            const result = hooks.beforeDelete(id);
+                            if (result === false) return;
+                        }
                         if (this._softDeletes) {
                             // Soft delete: set deletedAt instead of removing
                             const now = new Date().toISOString();
                             this.db.query(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`).run(now, id);
+                            if (hooks?.afterDelete) hooks.afterDelete(id);
                             return;
                         }
                         return deleteEntity(this._ctx, entityName, id);

package/src/types.ts

@@ -19,6 +19,16 @@ export const asZodObject = (s: z.ZodType<any>) => s as unknown as z.ZodObject<an
 /** Index definition: single column or composite columns */
 export type IndexDef = string | string[];
 
+/** Lifecycle hooks for a single table. */
+export type TableHooks = {
+    beforeInsert?: (data: Record<string, any>) => Record<string, any> | void;
+    afterInsert?: (entity: Record<string, any>) => void;
+    beforeUpdate?: (data: Record<string, any>, id: number) => Record<string, any> | void;
+    afterUpdate?: (entity: Record<string, any>) => void;
+    beforeDelete?: (id: number) => false | void;
+    afterDelete?: (id: number) => void;
+};
+
 export type DatabaseOptions<R extends RelationsConfig = RelationsConfig> = {
     indexes?: Record<string, IndexDef[]>;
     /**
@@ -65,6 +75,17 @@ export type DatabaseOptions<R extends RelationsConfig = RelationsConfig> = {
      * Default: `false`.
      */
     debug?: boolean;
+    /**
+     * Lifecycle hooks per table. Each hook receives data and can transform it.
+     *
+     * - `beforeInsert(data)` — called before insert, return modified data or void
+     * - `afterInsert(entity)` — called after insert with the persisted entity
+     * - `beforeUpdate(data, id)` — called before update, return modified data or void
+     * - `afterUpdate(entity)` — called after update with the updated entity
+     * - `beforeDelete(id)` — called before delete, return false to cancel
+     * - `afterDelete(id)` — called after delete
+     */
+    hooks?: Record<string, TableHooks>;
 };
 
 export type Relationship = {
@@ -184,6 +205,7 @@ export type NavEntityAccessor<
     update: ((id: number, data: Partial<Omit<z.input<S[Table & keyof S]>, 'id'>>) => NavEntity<S, R, Table> | null)
     & ((data: Partial<Omit<z.input<S[Table & keyof S]>, 'id'>>) => UpdateBuilder<NavEntity<S, R, Table>>);
     upsert: (conditions?: Partial<z.infer<S[Table & keyof S]>>, data?: Partial<z.infer<S[Table & keyof S]>>) => NavEntity<S, R, Table>;
+    upsertMany: (rows: Partial<z.infer<S[Table & keyof S]>>[], conditions?: Partial<z.infer<S[Table & keyof S]>>) => NavEntity<S, R, Table>[];
     delete: ((id: number) => void) & (() => DeleteBuilder<NavEntity<S, R, Table>>);
     restore: (id: number) => void;
     select: (...cols: (keyof z.infer<S[Table & keyof S]> & string)[]) => QueryBuilder<NavEntity<S, R, Table>>;
@@ -215,6 +237,7 @@ export type EntityAccessor<S extends z.ZodType<any>> = {
     insertMany: (rows: EntityData<S>[]) => AugmentedEntity<S>[];
     update: ((id: number, data: Partial<EntityData<S>>) => AugmentedEntity<S> | null) & ((data: Partial<EntityData<S>>) => UpdateBuilder<AugmentedEntity<S>>);
     upsert: (conditions?: Partial<InferSchema<S>>, data?: Partial<InferSchema<S>>) => AugmentedEntity<S>;
+    upsertMany: (rows: Partial<InferSchema<S>>[], conditions?: Partial<InferSchema<S>>) => AugmentedEntity<S>[];
     delete: ((id: number) => void) & (() => DeleteBuilder<AugmentedEntity<S>>);
     /** Undo a soft delete by setting deletedAt = null. Requires softDeletes. */
     restore: (id: number) => void;