sqlite-zod-orm 3.15.0 → 3.17.0

package/dist/index.js

@@ -5147,6 +5147,16 @@ function attachMethods(ctx, entityName, entity) {
       }
     }
   }
+  const computedGetters = ctx.computed[entityName];
+  if (computedGetters) {
+    for (const [key, fn] of Object.entries(computedGetters)) {
+      Object.defineProperty(augmented, key, {
+        get: () => fn(augmented),
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
   const storableFieldNames = new Set(getStorableFields(ctx.schemas[entityName]).map((f) => f.name));
   return new Proxy(augmented, {
     set: (target, prop, value) => {
@@ -5196,7 +5206,9 @@ class _Database {
       debug: this._debug,
       timestamps: this._timestamps,
       softDeletes: this._softDeletes,
-      hooks: options.hooks ?? {}
+      hooks: options.hooks ?? {},
+      computed: options.computed ?? {},
+      cascade: options.cascade ?? {}
     };
     this.initializeTables();
     if (this._reactive)
@@ -5227,6 +5239,20 @@ class _Database {
               if (result === false)
                 return;
             }
+            const cascadeTargets = this._ctx.cascade[entityName];
+            if (cascadeTargets) {
+              for (const childTable of cascadeTargets) {
+                const rel = this._ctx.relationships.find((r) => r.type === "belongs-to" && r.from === childTable && r.to === entityName);
+                if (rel) {
+                  if (this._softDeletes) {
+                    const now = new Date().toISOString();
+                    this.db.query(`UPDATE "${childTable}" SET "deletedAt" = ? WHERE "${rel.foreignKey}" = ?`).run(now, id);
+                  } else {
+                    this.db.query(`DELETE FROM "${childTable}" WHERE "${rel.foreignKey}" = ?`).run(id);
+                  }
+                }
+              }
+            }
             if (this._softDeletes) {
               const now = new Date().toISOString();
               this.db.query(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`).run(now, id);
@@ -5246,6 +5272,10 @@ class _Database {
           this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
         },
         select: (...cols) => createQueryBuilder(this._ctx, entityName, cols),
+        count: () => {
+          const row = this.db.query(`SELECT COUNT(*) as count FROM "${entityName}"${this._softDeletes ? ' WHERE "deletedAt" IS NULL' : ""}`).get();
+          return row?.count ?? 0;
+        },
         on: (event, callback) => {
           return this._registerListener(entityName, event, callback);
         },
@@ -5419,6 +5449,40 @@ class _Database {
   columns(tableName) {
     return this.db.query(`PRAGMA table_info("${tableName}")`).all();
   }
+  dump() {
+    const result = {};
+    for (const tableName of Object.keys(this.schemas)) {
+      result[tableName] = this.db.query(`SELECT * FROM "${tableName}"`).all();
+    }
+    return result;
+  }
+  load(data, options) {
+    const txn = this.db.transaction(() => {
+      for (const [tableName, rows] of Object.entries(data)) {
+        if (!this.schemas[tableName])
+          continue;
+        if (!options?.append) {
+          this.db.run(`DELETE FROM "${tableName}"`);
+        }
+        for (const row of rows) {
+          const cols = Object.keys(row).filter((k) => k !== "id");
+          const placeholders = cols.map(() => "?").join(", ");
+          const values = cols.map((c) => {
+            const v = row[c];
+            if (v !== null && v !== undefined && typeof v === "object" && !(v instanceof Buffer)) {
+              return JSON.stringify(v);
+            }
+            return v;
+          });
+          this.db.query(`INSERT INTO "${tableName}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`).run(...values);
+        }
+      }
+    });
+    txn();
+  }
+  seed(fixtures) {
+    this.load(fixtures, { append: true });
+  }
 }
 var Database = _Database;
 export {

package/package.json

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

package/src/context.ts

@@ -34,4 +34,10 @@ export interface DatabaseContext {
 
     /** Lifecycle hooks keyed by table name. */
     hooks: Record<string, TableHooks>;
+
+    /** Computed/virtual getters per table. */
+    computed: Record<string, Record<string, (entity: Record<string, any>) => any>>;
+
+    /** Cascade delete config — parent table → list of child tables to auto-delete. */
+    cascade: Record<string, string[]>;
 }

package/src/database.ts

@@ -87,6 +87,8 @@ class _Database<Schemas extends SchemaMap> {
             timestamps: this._timestamps,
             softDeletes: this._softDeletes,
             hooks: options.hooks ?? {},
+            computed: options.computed ?? {},
+            cascade: options.cascade ?? {},
         };
 
         this.initializeTables();
@@ -116,8 +118,27 @@ class _Database<Schemas extends SchemaMap> {
                             const result = hooks.beforeDelete(id);
                             if (result === false) return;
                         }
+
+                        // Cascade delete children first
+                        const cascadeTargets = this._ctx.cascade[entityName];
+                        if (cascadeTargets) {
+                            for (const childTable of cascadeTargets) {
+                                // Find FK from child → this parent via relationships
+                                const rel = this._ctx.relationships.find(
+                                    r => r.type === 'belongs-to' && r.from === childTable && r.to === entityName
+                                );
+                                if (rel) {
+                                    if (this._softDeletes) {
+                                        const now = new Date().toISOString();
+                                        this.db.query(`UPDATE "${childTable}" SET "deletedAt" = ? WHERE "${rel.foreignKey}" = ?`).run(now, id);
+                                    } else {
+                                        this.db.query(`DELETE FROM "${childTable}" WHERE "${rel.foreignKey}" = ?`).run(id);
+                                    }
+                                }
+                            }
+                        }
+
                         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);
@@ -133,6 +154,10 @@ class _Database<Schemas extends SchemaMap> {
                     this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
                 }) as any,
                 select: (...cols: string[]) => createQueryBuilder(this._ctx, entityName, cols),
+                count: () => {
+                    const row = this.db.query(`SELECT COUNT(*) as count FROM "${entityName}"${this._softDeletes ? ' WHERE "deletedAt" IS NULL' : ''}`).get() as any;
+                    return row?.count ?? 0;
+                },
                 on: (event: ChangeEvent, callback: (row: any) => void | Promise<void>) => {
                     return this._registerListener(entityName, event, callback);
                 },
@@ -395,6 +420,59 @@ class _Database<Schemas extends SchemaMap> {
     public columns(tableName: string): { name: string; type: string; notnull: number; pk: number }[] {
         return this.db.query(`PRAGMA table_info("${tableName}")`).all() as any[];
     }
+
+    // =========================================================================
+    // Data Import / Export
+    // =========================================================================
+
+    /**
+     * Export all data as a JSON-serializable object.
+     * Each key is a table name, value is an array of raw row objects.
+     */
+    public dump(): Record<string, any[]> {
+        const result: Record<string, any[]> = {};
+        for (const tableName of Object.keys(this.schemas)) {
+            result[tableName] = this.db.query(`SELECT * FROM "${tableName}"`).all();
+        }
+        return result;
+    }
+
+    /**
+     * Import data from a dump object. Truncates existing data first.
+     * Use `{ append: true }` to insert without truncating.
+     */
+    public load(data: Record<string, any[]>, options?: { append?: boolean }): void {
+        const txn = this.db.transaction(() => {
+            for (const [tableName, rows] of Object.entries(data)) {
+                if (!this.schemas[tableName]) continue;
+                if (!options?.append) {
+                    this.db.run(`DELETE FROM "${tableName}"`);
+                }
+                for (const row of rows) {
+                    const cols = Object.keys(row).filter(k => k !== 'id');
+                    const placeholders = cols.map(() => '?').join(', ');
+                    const values = cols.map(c => {
+                        const v = row[c];
+                        // Auto-serialize objects/arrays
+                        if (v !== null && v !== undefined && typeof v === 'object' && !(v instanceof Buffer)) {
+                            return JSON.stringify(v);
+                        }
+                        return v;
+                    });
+                    this.db.query(`INSERT INTO "${tableName}" (${cols.map(c => `"${c}"`).join(', ')}) VALUES (${placeholders})`).run(...values);
+                }
+            }
+        });
+        txn();
+    }
+
+    /**
+     * Seed tables with fixture data. Each key is a table name, value is an
+     * array of records to insert. Does NOT truncate — use for additive seeding.
+     */
+    public seed(fixtures: Record<string, Record<string, any>[]>): void {
+        this.load(fixtures, { append: true });
+    }
 }
 
 // =============================================================================

package/src/entity.ts

@@ -47,6 +47,18 @@ export function attachMethods<T extends Record<string, any>>(
         }
     }
 
+    // Attach computed/virtual getters from context
+    const computedGetters = ctx.computed[entityName];
+    if (computedGetters) {
+        for (const [key, fn] of Object.entries(computedGetters)) {
+            Object.defineProperty(augmented, key, {
+                get: () => fn(augmented),
+                enumerable: true,
+                configurable: true,
+            });
+        }
+    }
+
     // Auto-persist proxy: setting a field auto-updates the DB row
     const storableFieldNames = new Set(getStorableFields(ctx.schemas[entityName]!).map(f => f.name));
     return new Proxy(augmented, {

package/src/types.ts

@@ -86,6 +86,20 @@ export type DatabaseOptions<R extends RelationsConfig = RelationsConfig> = {
      * - `afterDelete(id)` — called after delete
      */
     hooks?: Record<string, TableHooks>;
+    /**
+     * Computed/virtual getters per table. Injected on every read.
+     * ```ts
+     * computed: { users: { fullName: (u) => u.first + ' ' + u.last } }
+     * ```
+     */
+    computed?: Record<string, Record<string, (entity: Record<string, any>) => any>>;
+    /**
+     * Cascade delete config per table. When a parent is deleted, children are auto-deleted.
+     * ```ts
+     * cascade: { authors: ['books'] }  // deleting author → deletes their books
+     * ```
+     */
+    cascade?: Record<string, string[]>;
 };
 
 export type Relationship = {
@@ -213,6 +227,7 @@ export type NavEntityAccessor<
         (): QueryBuilder<NavEntity<S, R, Table>>;
         <K extends (keyof z.infer<S[Table & keyof S]> | 'id') & string>(...cols: K[]): QueryBuilder<NavEntity<S, R, Table>, Pick<NavEntity<S, R, Table>, K>>;
     };
+    count: () => number;
     on: ((event: 'insert' | 'update', callback: (row: NavEntity<S, R, Table>) => void | Promise<void>) => () => void) &
     ((event: 'delete', callback: (row: { id: number }) => void | Promise<void>) => () => void);
     _tableName: string;
@@ -250,6 +265,7 @@ export type EntityAccessor<S extends z.ZodType<any>> = {
         (): QueryBuilder<AugmentedEntity<S>>;
         <K extends (keyof InferSchema<S> | 'id') & string>(...cols: K[]): QueryBuilder<AugmentedEntity<S>, Pick<AugmentedEntity<S>, K>>;
     };
+    count: () => number;
     on: ((event: 'insert' | 'update', callback: (row: AugmentedEntity<S>) => void | Promise<void>) => () => void) &
     ((event: 'delete', callback: (row: { id: number }) => void | Promise<void>) => () => void);
     _tableName: string;