sqlite-zod-orm 3.22.0 → 3.24.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, {
@@ -4620,6 +5003,18 @@ class QueryBuilder {
     const result = this.executor(`SELECT changes() as c`, [], true);
     return result[0]?.c ?? 0;
   }
+  increment(column, amount = 1) {
+    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 sql = `UPDATE "${this.tableName}" SET "${column}" = "${column}" + ? WHERE ${wherePart}`;
+    this.executor(sql, [amount, ...params], true);
+    const result = this.executor(`SELECT changes() as c`, [], true);
+    return result[0]?.c ?? 0;
+  }
+  decrement(column, amount = 1) {
+    return this.increment(column, -amount);
+  }
   then(onfulfilled, onrejected) {
     try {
       const result = this.all();
@@ -5253,7 +5648,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");
@@ -5263,7 +5666,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 = {
@@ -5279,19 +5681,19 @@ class _Database {
       computed: options.computed ?? {},
       cascade: options.cascade ?? {}
     };
-    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);
@@ -5336,8 +5738,6 @@ class _Database {
         restore: (id) => {
           if (!this._softDeletes)
             throw new Error("restore() requires softDeletes: true");
-          if (this._debug)
-            console.log("[satidb]", `UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`, [id]);
           this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
         },
         select: (...cols) => createQueryBuilder(this._ctx, entityName, cols),

package/package.json

@@ -1,57 +1,58 @@
-{
-  "name": "sqlite-zod-orm",
-  "version": "3.22.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.24.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/builder.ts

@@ -572,6 +572,34 @@ export class QueryBuilder<T extends Record<string, any>, TResult extends Record<
         return (result[0] as any)?.c ?? 0;
     }
 
+    /**
+     * Atomically increment a numeric column for matching rows.
+     * Returns the number of affected rows.
+     * ```ts
+     * db.users.select().where({ id: 1 }).increment('score', 10)
+     * ```
+     */
+    increment(column: keyof T & string, amount: number = 1): 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 sql = `UPDATE "${this.tableName}" SET "${column}" = "${column}" + ? WHERE ${wherePart}`;
+        this.executor(sql, [amount, ...params], true);
+        const result = this.executor(`SELECT changes() as c`, [], true);
+        return (result[0] as any)?.c ?? 0;
+    }
+
+    /**
+     * Atomically decrement a numeric column for matching rows.
+     * Returns the number of affected rows.
+     * ```ts
+     * db.users.select().where({ id: 1 }).decrement('score', 5)
+     * ```
+     */
+    decrement(column: keyof T & string, amount: number = 1): number {
+        return this.increment(column, -amount);
+    }
 
     // ---------- Thenable (async/await support) ----------
 

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) : [];
 
@@ -91,18 +106,18 @@ class _Database<Schemas extends SchemaMap> {
             cascade: options.cascade ?? {},
         };
 
-        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);
                     return createUpdateBuilder(this._ctx, entityName, idOrData);
@@ -150,7 +165,7 @@ class _Database<Schemas extends SchemaMap> {
                 }) 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]);
+                    // debug log replaced by measure-fn instrumentation
                     this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
                 }) as any,
                 select: (...cols: string[]) => createQueryBuilder(this._ctx, entityName, cols),