sqlite-zod-orm 3.23.0 → 3.25.0

package/dist/index.js

@@ -13,6 +13,389 @@ var __export = (target, all) => {
 // src/database.ts
 import { Database as SqliteDatabase } from "bun:sqlite";
 
+// node_modules/measure-fn/index.ts
+var toAlpha = (num) => {
+  let result = "";
+  let n = num;
+  do {
+    result = String.fromCharCode(97 + n % 26) + result;
+    n = Math.floor(n / 26) - 1;
+  } while (n >= 0);
+  return result;
+};
+var maxResultLen = 80;
+var safeStringify = (value) => {
+  if (value === undefined)
+    return "";
+  if (value === null)
+    return "null";
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (typeof value === "function")
+    return `[Function: ${value.name || "anonymous"}]`;
+  if (typeof value === "symbol")
+    return value.toString();
+  if (typeof value === "string") {
+    const q = JSON.stringify(value);
+    return q.length > maxResultLen ? q.slice(0, maxResultLen - 1) + '\u2026"' : q;
+  }
+  try {
+    const seen = new WeakSet;
+    const str = JSON.stringify(value, (_key, val) => {
+      if (typeof val === "object" && val !== null) {
+        if (seen.has(val))
+          return "[Circular]";
+        seen.add(val);
+      }
+      if (typeof val === "function")
+        return `[Function: ${val.name || "anonymous"}]`;
+      if (typeof val === "bigint")
+        return `${val}n`;
+      return val;
+    });
+    return str.length > maxResultLen ? str.slice(0, maxResultLen) + "\u2026" : str;
+  } catch {
+    return String(value);
+  }
+};
+var formatDuration = (ms) => {
+  if (ms < 1000)
+    return `${ms.toFixed(2)}ms`;
+  if (ms < 60000)
+    return `${(ms / 1000).toFixed(1)}s`;
+  const mins = Math.floor(ms / 60000);
+  const secs = Math.round(ms % 60000 / 1000);
+  return `${mins}m ${secs}s`;
+};
+var timestamps = process.env.MEASURE_TIMESTAMPS === "1" || process.env.MEASURE_TIMESTAMPS === "true";
+var ts = () => {
+  if (!timestamps)
+    return "";
+  const now = new Date;
+  const h = String(now.getHours()).padStart(2, "0");
+  const m = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  const ms = String(now.getMilliseconds()).padStart(3, "0");
+  return `[${h}:${m}:${s}.${ms}] `;
+};
+var silent = process.env.MEASURE_SILENT === "1" || process.env.MEASURE_SILENT === "true";
+var logger = null;
+var buildActionLabel = (actionInternal) => {
+  return typeof actionInternal === "object" && actionInternal !== null && "label" in actionInternal ? String(actionInternal.label) : String(actionInternal);
+};
+var extractBudget = (actionInternal) => {
+  if (typeof actionInternal !== "object" || actionInternal === null)
+    return;
+  if ("budget" in actionInternal)
+    return Number(actionInternal.budget);
+  return;
+};
+var extractMeta = (actionInternal) => {
+  if (typeof actionInternal !== "object" || actionInternal === null)
+    return;
+  const details = { ...actionInternal };
+  if ("label" in details)
+    delete details.label;
+  if ("budget" in details)
+    delete details.budget;
+  if (Object.keys(details).length === 0)
+    return;
+  return details;
+};
+var formatMeta = (meta) => {
+  if (!meta)
+    return "";
+  const params = Object.entries(meta).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join(" ");
+  return ` (${params})`;
+};
+var emit = (event, prefix) => {
+  if (silent)
+    return;
+  if (logger) {
+    logger(event);
+    return;
+  }
+  defaultLogger(event, prefix);
+};
+var defaultLogger = (event, prefix) => {
+  const pfx = prefix ? `${prefix}:` : "";
+  const id = `[${pfx}${event.id}]`;
+  const t = ts();
+  switch (event.type) {
+    case "start":
+      console.log(`${t}${id} ... ${event.label}${formatMeta(event.meta)}`);
+      break;
+    case "success": {
+      const resultStr = event.result !== undefined ? safeStringify(event.result) : "";
+      const arrow = resultStr ? ` \u2192 ${resultStr}` : "";
+      const budgetWarn = event.budget && event.duration > event.budget ? ` \u26A0 OVER BUDGET (${formatDuration(event.budget)})` : "";
+      console.log(`${t}${id} \u2713 ${event.label} ${formatDuration(event.duration)}${arrow}${budgetWarn}`);
+      break;
+    }
+    case "error": {
+      const errorMsg = event.error instanceof Error ? event.error.message : String(event.error);
+      const budgetWarn = event.budget && event.duration > event.budget ? ` \u26A0 OVER BUDGET (${formatDuration(event.budget)})` : "";
+      console.log(`${t}${id} \u2717 ${event.label} ${formatDuration(event.duration)} (${errorMsg})${budgetWarn}`);
+      if (event.error instanceof Error) {
+        console.error(`${id}`, event.error.stack ?? event.error.message);
+        if (event.error.cause) {
+          console.error(`${id} Cause:`, event.error.cause);
+        }
+      } else {
+        console.error(`${id}`, event.error);
+      }
+      break;
+    }
+    case "annotation":
+      console.log(`${t}${id} = ${event.label}${formatMeta(event.meta)}`);
+      break;
+  }
+};
+var createNestedResolver = (isAsync, fullIdChain, childCounterRef, depth, resolver, prefix) => {
+  return (...args) => {
+    const label = args[0];
+    const fn = args[1];
+    if (typeof fn === "function") {
+      const childParentChain = [...fullIdChain, childCounterRef.value++];
+      return resolver(fn, label, childParentChain, depth + 1);
+    } else {
+      emit({
+        type: "annotation",
+        id: fullIdChain.join("-"),
+        label: buildActionLabel(label),
+        depth: depth + 1,
+        meta: extractMeta(label)
+      }, prefix);
+      return isAsync ? Promise.resolve(null) : null;
+    }
+  };
+};
+var globalRootCounter = 0;
+var createMeasureImpl = (prefix, counterRef) => {
+  const counter = counterRef ?? { get value() {
+    return globalRootCounter;
+  }, set value(v) {
+    globalRootCounter = v;
+  } };
+  let _lastError = null;
+  const _measureInternal = async (fnInternal, actionInternal, parentIdChain, depth) => {
+    const start = performance.now();
+    const childCounterRef = { value: 0 };
+    const label = buildActionLabel(actionInternal);
+    const budget = extractBudget(actionInternal);
+    const currentId = toAlpha(parentIdChain.pop() ?? 0);
+    const fullIdChain = [...parentIdChain, currentId];
+    const idStr = fullIdChain.join("-");
+    emit({
+      type: "start",
+      id: idStr,
+      label,
+      depth,
+      meta: extractMeta(actionInternal)
+    }, prefix);
+    const measureForNextLevel = createNestedResolver(true, fullIdChain, childCounterRef, depth, _measureInternal, prefix);
+    try {
+      const result = await fnInternal(measureForNextLevel);
+      const duration = performance.now() - start;
+      emit({ type: "success", id: idStr, label, depth, duration, result, budget }, prefix);
+      return result;
+    } catch (error) {
+      const duration = performance.now() - start;
+      emit({ type: "error", id: idStr, label, depth, duration, error, budget }, prefix);
+      _lastError = error;
+      return null;
+    }
+  };
+  const _measureInternalSync = (fnInternal, actionInternal, parentIdChain, depth) => {
+    const start = performance.now();
+    const childCounterRef = { value: 0 };
+    const label = buildActionLabel(actionInternal);
+    const hasNested = fnInternal.length > 0;
+    const budget = extractBudget(actionInternal);
+    const currentId = toAlpha(parentIdChain.pop() ?? 0);
+    const fullIdChain = [...parentIdChain, currentId];
+    const idStr = fullIdChain.join("-");
+    if (hasNested) {
+      emit({
+        type: "start",
+        id: idStr,
+        label,
+        depth,
+        meta: extractMeta(actionInternal)
+      }, prefix);
+    }
+    const measureForNextLevel = createNestedResolver(false, fullIdChain, childCounterRef, depth, _measureInternalSync, prefix);
+    try {
+      const result = fnInternal(measureForNextLevel);
+      const duration = performance.now() - start;
+      emit({ type: "success", id: idStr, label, depth, duration, result, budget }, prefix);
+      return result;
+    } catch (error) {
+      const duration = performance.now() - start;
+      emit({ type: "error", id: idStr, label, depth, duration, error, budget }, prefix);
+      _lastError = error;
+      return null;
+    }
+  };
+  const measureFn = async (arg1, arg2) => {
+    if (typeof arg2 === "function") {
+      return _measureInternal(arg2, arg1, [counter.value++], 0);
+    } else {
+      const currentId = toAlpha(counter.value++);
+      emit({
+        type: "annotation",
+        id: currentId,
+        label: buildActionLabel(arg1),
+        depth: 0,
+        meta: extractMeta(arg1)
+      }, prefix);
+      return Promise.resolve(null);
+    }
+  };
+  measureFn.timed = async (arg1, arg2) => {
+    const start = performance.now();
+    const result = await measureFn(arg1, arg2);
+    const duration = performance.now() - start;
+    return { result, duration };
+  };
+  measureFn.retry = async (label, opts, fn) => {
+    const attempts = opts.attempts ?? 3;
+    const delay = opts.delay ?? 1000;
+    const backoff = opts.backoff ?? 1;
+    const lbl = buildActionLabel(label);
+    const budget = extractBudget(label);
+    for (let i = 0;i < attempts; i++) {
+      const attempt = i + 1;
+      const attemptLabel = `${lbl} [${attempt}/${attempts}]`;
+      const start = performance.now();
+      const currentId = toAlpha(counter.value++);
+      emit({
+        type: "start",
+        id: currentId,
+        label: attemptLabel,
+        depth: 0,
+        meta: extractMeta(label)
+      }, prefix);
+      try {
+        const result = await fn();
+        const duration = performance.now() - start;
+        emit({ type: "success", id: currentId, label: attemptLabel, depth: 0, duration, result, budget }, prefix);
+        return result;
+      } catch (error) {
+        const duration = performance.now() - start;
+        emit({ type: "error", id: currentId, label: attemptLabel, depth: 0, duration, error, budget }, prefix);
+        if (attempt < attempts) {
+          await new Promise((r) => setTimeout(r, delay * Math.pow(backoff, i)));
+        }
+      }
+    }
+    return null;
+  };
+  measureFn.assert = async (arg1, arg2) => {
+    const result = await measureFn(arg1, arg2);
+    if (result === null) {
+      const cause = _lastError;
+      _lastError = null;
+      throw new Error(`measure.assert: "${buildActionLabel(arg1)}" failed`, { cause });
+    }
+    return result;
+  };
+  measureFn.wrap = (label, fn) => {
+    return (...args) => measureFn(label, () => fn(...args));
+  };
+  measureFn.batch = async (label, items, fn, opts) => {
+    const lbl = buildActionLabel(label);
+    const total = items.length;
+    const every = opts?.every ?? Math.max(1, Math.ceil(total / 5));
+    const currentId = toAlpha(counter.value++);
+    const startTime = performance.now();
+    emit({
+      type: "start",
+      id: currentId,
+      label: `${lbl} (${total} items)`,
+      depth: 0,
+      meta: extractMeta(label)
+    }, prefix);
+    const results = [];
+    for (let i = 0;i < items.length; i++) {
+      try {
+        results.push(await fn(items[i], i));
+      } catch {
+        results.push(null);
+      }
+      if ((i + 1) % every === 0 && i + 1 < total) {
+        const elapsed = (performance.now() - startTime) / 1000;
+        const rate = ((i + 1) / elapsed).toFixed(0);
+        emit({
+          type: "annotation",
+          id: currentId,
+          label: `${i + 1}/${total} (${elapsed.toFixed(1)}s, ${rate}/s)`,
+          depth: 0
+        }, prefix);
+      }
+    }
+    const duration = performance.now() - startTime;
+    const budget = extractBudget(label);
+    emit({
+      type: "success",
+      id: currentId,
+      label: `${lbl} (${total} items)`,
+      depth: 0,
+      duration,
+      result: `${results.filter((r) => r !== null).length}/${total} ok`,
+      budget
+    }, prefix);
+    return results;
+  };
+  const measureSyncFn = (arg1, arg2) => {
+    if (typeof arg2 === "function") {
+      return _measureInternalSync(arg2, arg1, [counter.value++], 0);
+    } else {
+      const currentId = toAlpha(counter.value++);
+      emit({
+        type: "annotation",
+        id: currentId,
+        label: buildActionLabel(arg1),
+        depth: 0,
+        meta: extractMeta(arg1)
+      }, prefix);
+      return null;
+    }
+  };
+  measureSyncFn.timed = (arg1, arg2) => {
+    const start = performance.now();
+    const result = measureSyncFn(arg1, arg2);
+    const duration = performance.now() - start;
+    return { result, duration };
+  };
+  measureSyncFn.assert = (arg1, arg2) => {
+    const result = measureSyncFn(arg1, arg2);
+    if (result === null) {
+      const cause = _lastError;
+      _lastError = null;
+      throw new Error(`measureSync.assert: "${buildActionLabel(arg1)}" failed`, { cause });
+    }
+    return result;
+  };
+  measureSyncFn.wrap = (label, fn) => {
+    return (...args) => measureSyncFn(label, () => fn(...args));
+  };
+  return { measure: measureFn, measureSync: measureSyncFn };
+};
+var globalInstance = createMeasureImpl();
+var measure = globalInstance.measure;
+var measureSync = globalInstance.measureSync;
+var createMeasure = (scopePrefix) => {
+  const scopeCounter = { value: 0 };
+  const scoped = createMeasureImpl(scopePrefix, scopeCounter);
+  return {
+    ...scoped,
+    resetCounter: () => {
+      scopeCounter.value = 0;
+    }
+  };
+};
+
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -4837,12 +5220,12 @@ 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;
-    return rows.map((row) => ctx.attachMethods(entityName, transformFromStorage(row, schema)));
+    return ctx._m(`SQL: ${sql.slice(0, 60)}`, () => {
+      const rows = ctx.db.query(sql).all(...params);
+      if (raw)
+        return rows;
+      return rows.map((row) => ctx.attachMethods(entityName, transformFromStorage(row, schema)));
+    });
   };
   const singleExecutor = (sql, params, raw) => {
     const results = executor(sql, params, raw);
@@ -5020,9 +5403,9 @@ function insert(ctx, entityName, data) {
   let inputData = { ...data };
   const hooks = ctx.hooks[entityName];
   if (hooks?.beforeInsert) {
-    const result2 = hooks.beforeInsert(inputData);
-    if (result2)
-      inputData = result2;
+    const result = hooks.beforeInsert(inputData);
+    if (result)
+      inputData = result;
   }
   const validatedData = asZodObject(schema).passthrough().parse(inputData);
   const transformed = transformForStorage(validatedData);
@@ -5034,10 +5417,12 @@ function insert(ctx, entityName, data) {
   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);
+  let lastId = 0;
+  ctx._m(`SQL: ${sql.slice(0, 40)}`, () => {
+    const result = ctx.db.query(sql).run(...Object.values(transformed));
+    lastId = result.lastInsertRowid;
+  });
+  const newEntity = getById(ctx, entityName, lastId);
   if (!newEntity)
     throw new Error("Failed to retrieve entity after insertion");
   if (hooks?.afterInsert)
@@ -5062,9 +5447,9 @@ function update(ctx, entityName, id, data) {
   }
   const setClause = Object.keys(transformed).map((key) => `"${key}" = ?`).join(", ");
   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);
+  ctx._m(`SQL: UPDATE ${entityName} SET ...`, () => {
+    ctx.db.query(sql).run(...Object.values(transformed), id);
+  });
   const updated = getById(ctx, entityName, id);
   if (hooks?.afterUpdate && updated)
     hooks.afterUpdate(updated);
@@ -5133,15 +5518,11 @@ function deleteWhere(ctx, entityName, conditions) {
   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);
+    const result2 = ctx._m(`SQL: ${sql2.slice(0, 50)}`, () => 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);
+  const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => ctx.db.query(sql).run(...values));
   return result.changes ?? 0;
 }
 function createDeleteBuilder(ctx, entityName) {
@@ -5265,7 +5646,15 @@ class _Database {
   _changeWatermark = 0;
   _pollTimer = null;
   _pollInterval;
+  _measure;
+  _m(label, fn) {
+    if (this._debug)
+      return this._measure.measureSync.assert(label, fn);
+    return fn();
+  }
   constructor(dbFile, schemas, options = {}) {
+    this._debug = options.debug === true;
+    this._measure = createMeasure("satidb");
     this.db = new SqliteDatabase(dbFile);
     if (options.wal !== false)
       this.db.run("PRAGMA journal_mode = WAL");
@@ -5275,7 +5664,6 @@ class _Database {
     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 = {
@@ -5289,74 +5677,77 @@ class _Database {
       softDeletes: this._softDeletes,
       hooks: options.hooks ?? {},
       computed: options.computed ?? {},
-      cascade: options.cascade ?? {}
+      cascade: options.cascade ?? {},
+      _m: (label, fn) => this._m(label, fn)
     };
-    this.initializeTables();
+    this._m("Init tables", () => this.initializeTables());
     if (this._reactive)
-      this.initializeChangeTracking();
-    this.runMigrations();
+      this._m("Change tracking", () => this.initializeChangeTracking());
+    this._m("Run migrations", () => this.runMigrations());
     if (options.indexes)
-      this.createIndexes(options.indexes);
+      this._m("Create indexes", () => this.createIndexes(options.indexes));
     if (options.unique)
-      this.createUniqueConstraints(options.unique);
+      this._m("Unique constraints", () => this.createUniqueConstraints(options.unique));
     for (const entityName of Object.keys(schemas)) {
       const key = entityName;
       const accessor = {
-        insert: (data) => insert(this._ctx, entityName, data),
-        insertMany: (rows) => insertMany(this._ctx, entityName, rows),
+        insert: (data) => this._m(`${entityName}.insert`, () => insert(this._ctx, entityName, data)),
+        insertMany: (rows) => this._m(`${entityName}.insertMany(${rows.length})`, () => insertMany(this._ctx, entityName, rows)),
         update: (idOrData, data) => {
           if (typeof idOrData === "number")
-            return update(this._ctx, entityName, idOrData, data);
+            return this._m(`${entityName}.update(${idOrData})`, () => update(this._ctx, entityName, idOrData, data));
           return createUpdateBuilder(this._ctx, entityName, idOrData);
         },
-        upsert: (conditions, data) => upsert(this._ctx, entityName, data, conditions),
-        upsertMany: (rows, conditions) => upsertMany(this._ctx, entityName, rows, conditions),
-        findOrCreate: (conditions, defaults) => findOrCreate(this._ctx, entityName, conditions, defaults),
+        upsert: (conditions, data) => this._m(`${entityName}.upsert`, () => upsert(this._ctx, entityName, data, conditions)),
+        upsertMany: (rows, conditions) => this._m(`${entityName}.upsertMany(${rows.length})`, () => upsertMany(this._ctx, entityName, rows, conditions)),
+        findOrCreate: (conditions, defaults) => this._m(`${entityName}.findOrCreate`, () => findOrCreate(this._ctx, entityName, conditions, defaults)),
         delete: (id) => {
           if (typeof id === "number") {
-            const hooks = this._ctx.hooks[entityName];
-            if (hooks?.beforeDelete) {
-              const result = hooks.beforeDelete(id);
-              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);
+            return this._m(`${entityName}.delete(${id})`, () => {
+              const hooks = this._ctx.hooks[entityName];
+              if (hooks?.beforeDelete) {
+                const result = hooks.beforeDelete(id);
+                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);
-              if (hooks?.afterDelete)
-                hooks.afterDelete(id);
-              return;
-            }
-            return deleteEntity(this._ctx, entityName, id);
+              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);
+            });
           }
           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);
+          this._m(`${entityName}.restore(${id})`, () => {
+            this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
+          });
         },
         select: (...cols) => createQueryBuilder(this._ctx, entityName, cols),
-        count: () => {
+        count: () => this._m(`${entityName}.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);
         },
@@ -5501,28 +5892,22 @@ class _Database {
     this.db.query('DELETE FROM "_changes" WHERE id <= ?').run(this._changeWatermark);
   }
   transaction(callback) {
-    return this.db.transaction(callback)();
+    return this._m("transaction", () => this.db.transaction(callback)());
   }
   close() {
     this._stopPolling();
     this.db.close();
   }
   query(callback) {
-    return executeProxyQuery(this.schemas, callback, (sql, params) => {
-      if (this._debug)
-        console.log("[satidb]", sql, params);
+    return this._m("query(proxy)", () => executeProxyQuery(this.schemas, callback, (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);
+    return this._m(`raw: ${sql.slice(0, 60)}`, () => this.db.query(sql).all(...params));
   }
   exec(sql, ...params) {
-    if (this._debug)
-      console.log("[satidb]", sql, params);
-    this.db.run(sql, ...params);
+    this._m(`exec: ${sql.slice(0, 60)}`, () => this.db.run(sql, ...params));
   }
   tables() {
     return Object.keys(this.schemas);
@@ -5531,70 +5916,76 @@ class _Database {
     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;
+    return this._m("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);
+    this._m(`load(${Object.keys(data).join(",")})`, () => {
+      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();
     });
-    txn();
   }
   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 });
+    return this._m("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);
+        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 };
         }
       }
-      if (added.length > 0 || removed.length > 0 || typeChanged.length > 0) {
-        result[tableName] = { added, removed, typeChanged };
-      }
-    }
-    return result;
+      return result;
+    });
   }
 }
 var Database = _Database;

package/package.json

@@ -1,57 +1,58 @@
-{
-  "name": "sqlite-zod-orm",
-  "version": "3.23.0",
-  "description": "Type-safe SQLite ORM for Bun — Zod schemas, fluent queries, auto relationships, zero SQL",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./src/index.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./src/index.ts"
-    }
-  },
-  "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun --format esm",
-    "clean": "rm -rf dist",
-    "test": "bun test",
-    "bench": "bun bench/triggers-vs-naive.ts && bun bench/poll-strategy.ts && bun bench/indexes.ts",
-    "prepublishOnly": "bun run build"
-  },
-  "files": [
-    "src",
-    "dist",
-    "README.md"
-  ],
-  "keywords": [
-    "sqlite",
-    "database",
-    "bun",
-    "typescript",
-    "type-safe",
-    "orm",
-    "zod",
-    "sql",
-    "query-builder",
-    "relationships"
-  ],
-  "author": "7flash",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:7flash/sqlite-zod-orm.git"
-  },
-  "devDependencies": {
-    "bun-types": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "zod": "^3.25.67"
-  },
-  "engines": {
-    "bun": ">=1.0.0"
-  }
+{
+  "name": "sqlite-zod-orm",
+  "version": "3.25.0",
+  "description": "Type-safe SQLite ORM for Bun — Zod schemas, fluent queries, auto relationships, zero SQL",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --format esm",
+    "clean": "rm -rf dist",
+    "test": "bun test",
+    "bench": "bun bench/triggers-vs-naive.ts && bun bench/poll-strategy.ts && bun bench/indexes.ts",
+    "prepublishOnly": "bun run build"
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "sqlite",
+    "database",
+    "bun",
+    "typescript",
+    "type-safe",
+    "orm",
+    "zod",
+    "sql",
+    "query-builder",
+    "relationships"
+  ],
+  "author": "7flash",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:7flash/sqlite-zod-orm.git"
+  },
+  "devDependencies": {
+    "bun-types": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "measure-fn": "^3.3.0",
+    "zod": "^3.25.67"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
 }

package/src/context.ts

@@ -40,4 +40,10 @@ export interface DatabaseContext {
 
     /** Cascade delete config — parent table → list of child tables to auto-delete. */
     cascade: Record<string, string[]>;
+
+    /**
+     * Conditional measurement helper — wraps fn with measure-fn when debug is on.
+     * When debug is off, executes fn directly with zero overhead.
+     */
+    _m<T>(label: string, fn: () => T): T;
 }

package/src/crud.ts

@@ -66,9 +66,12 @@ 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);
+    let lastId = 0;
+    ctx._m(`SQL: ${sql.slice(0, 40)}`, () => {
+        const result = ctx.db.query(sql).run(...Object.values(transformed));
+        lastId = result.lastInsertRowid as number;
+    });
+    const newEntity = getById(ctx, entityName, lastId);
     if (!newEntity) throw new Error('Failed to retrieve entity after insertion');
 
     // afterInsert hook
@@ -99,8 +102,9 @@ export function update<T extends Record<string, any>>(ctx: DatabaseContext, enti
 
     const setClause = Object.keys(transformed).map(key => `"${key}" = ?`).join(', ');
     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);
+    ctx._m(`SQL: UPDATE ${entityName} SET ...`, () => {
+        ctx.db.query(sql).run(...Object.values(transformed), id);
+    });
 
     const updated = getById(ctx, entityName, id);
 
@@ -192,14 +196,12 @@ export function deleteWhere(ctx: DatabaseContext, entityName: string, conditions
         // 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);
+        const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => 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);
+    const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => ctx.db.query(sql).run(...values));
     return (result as any).changes ?? 0;
 }
 

package/src/database.ts

@@ -6,6 +6,7 @@
  * focused modules.
  */
 import { Database as SqliteDatabase } from 'bun:sqlite';
+import { createMeasure } from 'measure-fn';
 import { z } from 'zod';
 import { QueryBuilder, executeProxyQuery, createQueryBuilder, type ProxyQueryResult } from './query';
 import type {
@@ -63,7 +64,22 @@ class _Database<Schemas extends SchemaMap> {
     /** Poll interval in ms. */
     private _pollInterval: number;
 
+    /** Scoped measure-fn instance for instrumentation. */
+    private _measure: ReturnType<typeof createMeasure>;
+
+    /**
+     * Conditional measurement helper — wraps with measure-fn only when debug is on.
+     * When debug is off, executes fn directly with zero overhead.
+     */
+    private _m<T>(label: string, fn: () => T): T {
+        if (this._debug) return this._measure.measureSync.assert(label, fn);
+        return fn();
+    }
+
     constructor(dbFile: string, schemas: Schemas, options: DatabaseOptions = {}) {
+        this._debug = options.debug === true;
+        this._measure = createMeasure('satidb');
+
         this.db = new SqliteDatabase(dbFile);
         if (options.wal !== false) this.db.run('PRAGMA journal_mode = WAL');
         this.db.run('PRAGMA foreign_keys = ON');
@@ -72,7 +88,6 @@ class _Database<Schemas extends SchemaMap> {
         this._reactive = options.reactive !== false; // default true
         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) : [];
 
@@ -89,75 +104,78 @@ class _Database<Schemas extends SchemaMap> {
             hooks: options.hooks ?? {},
             computed: options.computed ?? {},
             cascade: options.cascade ?? {},
+            _m: <T>(label: string, fn: () => T): T => this._m(label, fn),
         };
 
-        this.initializeTables();
-        if (this._reactive) this.initializeChangeTracking();
-        this.runMigrations();
-        if (options.indexes) this.createIndexes(options.indexes);
-        if (options.unique) this.createUniqueConstraints(options.unique);
+        this._m('Init tables', () => this.initializeTables());
+        if (this._reactive) this._m('Change tracking', () => this.initializeChangeTracking());
+        this._m('Run migrations', () => this.runMigrations());
+        if (options.indexes) this._m('Create indexes', () => this.createIndexes(options.indexes!));
+        if (options.unique) this._m('Unique constraints', () => this.createUniqueConstraints(options.unique!));
 
         // Create typed entity accessors (db.users, db.posts, etc.)
         for (const entityName of Object.keys(schemas)) {
             const key = entityName as keyof Schemas;
             const accessor: EntityAccessor<Schemas[typeof key]> = {
-                insert: (data) => insert(this._ctx, entityName, data),
-                insertMany: (rows: any[]) => insertMany(this._ctx, entityName, rows),
+                insert: (data) => this._m(`${entityName}.insert`, () => insert(this._ctx, entityName, data)),
+                insertMany: (rows: any[]) => this._m(`${entityName}.insertMany(${rows.length})`, () => insertMany(this._ctx, entityName, rows)),
                 update: (idOrData: any, data?: any) => {
-                    if (typeof idOrData === 'number') return update(this._ctx, entityName, idOrData, data);
+                    if (typeof idOrData === 'number') return this._m(`${entityName}.update(${idOrData})`, () => update(this._ctx, entityName, idOrData, data));
                     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),
-                findOrCreate: (conditions: any, defaults?: any) => findOrCreate(this._ctx, entityName, conditions, defaults),
+                upsert: (conditions, data) => this._m(`${entityName}.upsert`, () => upsert(this._ctx, entityName, data, conditions)),
+                upsertMany: (rows: any[], conditions?: any) => this._m(`${entityName}.upsertMany(${rows.length})`, () => upsertMany(this._ctx, entityName, rows, conditions)),
+                findOrCreate: (conditions: any, defaults?: any) => this._m(`${entityName}.findOrCreate`, () => findOrCreate(this._ctx, entityName, conditions, defaults)),
                 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;
-                        }
+                        return this._m(`${entityName}.delete(${id})`, () => {
+                            // beforeDelete hook — return false to cancel
+                            const hooks = this._ctx.hooks[entityName];
+                            if (hooks?.beforeDelete) {
+                                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);
+                            // Cascade delete children first
+                            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);
-                            if (hooks?.afterDelete) hooks.afterDelete(id);
-                            return;
-                        }
-                        return deleteEntity(this._ctx, entityName, id);
+                            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);
+                        });
                     }
                     return createDeleteBuilder(this._ctx, entityName);
                 }) as any,
                 restore: ((id: number) => {
                     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);
+                    this._m(`${entityName}.restore(${id})`, () => {
+                        this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
+                    });
                 }) as any,
                 select: (...cols: string[]) => createQueryBuilder(this._ctx, entityName, cols),
-                count: () => {
+                count: () => this._m(`${entityName}.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);
                 },
@@ -364,7 +382,7 @@ class _Database<Schemas extends SchemaMap> {
     // =========================================================================
 
     public transaction<T>(callback: () => T): T {
-        return this.db.transaction(callback)();
+        return this._m('transaction', () => this.db.transaction(callback)());
     }
 
     /** Close the database: stops polling and releases the SQLite handle. */
@@ -381,14 +399,13 @@ class _Database<Schemas extends SchemaMap> {
     public query<T extends Record<string, any> = Record<string, any>>(
         callback: (ctx: { [K in keyof Schemas]: ProxyColumns<InferSchema<Schemas[K]>> }) => ProxyQueryResult
     ): T[] {
-        return executeProxyQuery(
+        return this._m('query(proxy)', () => executeProxyQuery(
             this.schemas,
             callback as any,
             (sql: string, params: any[]) => {
-                if (this._debug) console.log('[satidb]', sql, params);
                 return this.db.query(sql).all(...params) as T[];
             },
-        );
+        ));
     }
 
     // =========================================================================
@@ -397,14 +414,12 @@ class _Database<Schemas extends SchemaMap> {
 
     /** Execute a raw SQL query and return results. */
     public raw<T = any>(sql: string, ...params: any[]): T[] {
-        if (this._debug) console.log('[satidb]', sql, params);
-        return this.db.query(sql).all(...params) as T[];
+        return this._m(`raw: ${sql.slice(0, 60)}`, () => this.db.query(sql).all(...params) as T[]);
     }
 
     /** Execute a raw SQL statement (INSERT/UPDATE/DELETE) without returning rows. */
     public exec(sql: string, ...params: any[]): void {
-        if (this._debug) console.log('[satidb]', sql, params);
-        this.db.run(sql, ...params);
+        this._m(`exec: ${sql.slice(0, 60)}`, () => this.db.run(sql, ...params));
     }
 
     // =========================================================================
@@ -430,11 +445,13 @@ class _Database<Schemas extends SchemaMap> {
      * 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;
+        return this._m('dump', () => {
+            const result: Record<string, any[]> = {};
+            for (const tableName of Object.keys(this.schemas)) {
+                result[tableName] = this.db.query(`SELECT * FROM "${tableName}"`).all();
+            }
+            return result;
+        });
     }
 
     /**
@@ -442,28 +459,29 @@ class _Database<Schemas extends SchemaMap> {
      * 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);
+        this._m(`load(${Object.keys(data).join(',')})`, () => {
+            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();
         });
-        txn();
     }
 
     /**
@@ -483,45 +501,45 @@ class _Database<Schemas extends SchemaMap> {
      * 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 });
+        return this._m('diff', () => {
+            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 }[] = [];
+
+                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);
+                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 };
+                if (added.length > 0 || removed.length > 0 || typeChanged.length > 0) {
+                    result[tableName] = { added, removed, typeChanged };
+                }
             }
-        }
 
-        return result;
+            return result;
+        });
     }
 }
 

package/src/query.ts

@@ -39,10 +39,11 @@ export function createQueryBuilder(ctx: DatabaseContext, entityName: string, ini
     const schema = ctx.schemas[entityName]!;
 
     const executor = (sql: string, params: any[], raw: boolean): any[] => {
-        if (ctx.debug) console.log('[satidb]', sql, params);
-        const rows = ctx.db.query(sql).all(...params);
-        if (raw) return rows;
-        return rows.map((row: any) => ctx.attachMethods(entityName, transformFromStorage(row, schema)));
+        return ctx._m(`SQL: ${sql.slice(0, 60)}`, () => {
+            const rows = ctx.db.query(sql).all(...params);
+            if (raw) return rows;
+            return rows.map((row: any) => ctx.attachMethods(entityName, transformFromStorage(row, schema)));
+        });
     };
 
     const singleExecutor = (sql: string, params: any[], raw: boolean): any | null => {