@objectstack/objectql 7.8.0 → 8.0.0

package/dist/index.mjs

@@ -2386,6 +2386,44 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
       }
     } catch {
     }
+    if (request.previewDrafts) {
+      try {
+        const orgId = request.organizationId;
+        const queryDrafts = async (oid) => {
+          const whereClause = { type: request.type, state: "draft", organization_id: oid };
+          if (packageId) whereClause.package_id = packageId;
+          let rs = await this.engine.find("sys_metadata", { where: whereClause });
+          if (!rs || rs.length === 0) {
+            const alt = PLURAL_TO_SINGULAR3[request.type] ?? SINGULAR_TO_PLURAL2[request.type];
+            if (alt) {
+              const altWhere = { type: alt, state: "draft", organization_id: oid };
+              if (packageId) altWhere.package_id = packageId;
+              rs = await this.engine.find("sys_metadata", { where: altWhere });
+            }
+          }
+          return rs ?? [];
+        };
+        const draftRecords = [...await queryDrafts(null), ...orgId ? await queryDrafts(orgId) : []];
+        if (draftRecords.length > 0) {
+          const byName = /* @__PURE__ */ new Map();
+          for (const existing of items) {
+            const entry = existing;
+            if (entry && typeof entry === "object" && "name" in entry) byName.set(entry.name, entry);
+          }
+          for (const record of draftRecords) {
+            const data = typeof record.metadata === "string" ? JSON.parse(record.metadata) : record.metadata;
+            if (data && typeof data === "object" && "name" in data) {
+              const recPkg = record.package_id ?? void 0;
+              if (recPkg && data._packageId === void 0) data._packageId = recPkg;
+              data._draft = true;
+              byName.set(data.name, data);
+            }
+          }
+          items = Array.from(byName.values());
+        }
+      } catch {
+      }
+    }
     try {
       const services = this.getServicesRegistry?.();
       const metadataService = services?.get("metadata");
@@ -2444,6 +2482,34 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
     let item;
     const orgId = request.organizationId;
     const readState = request.state === "draft" ? "draft" : "active";
+    if (request.previewDrafts && readState !== "draft") {
+      try {
+        const findDraft = async (oid) => {
+          const rec = await this.engine.findOne("sys_metadata", {
+            where: { type: request.type, name: request.name, state: "draft", organization_id: oid }
+          });
+          if (rec) return rec;
+          const alt = PLURAL_TO_SINGULAR3[request.type] ?? SINGULAR_TO_PLURAL2[request.type];
+          if (alt) {
+            return await this.engine.findOne("sys_metadata", {
+              where: { type: alt, name: request.name, state: "draft", organization_id: oid }
+            });
+          }
+          return void 0;
+        };
+        const draftRec = (orgId ? await findDraft(orgId) : void 0) ?? await findDraft(null);
+        if (draftRec) {
+          const draftItem = typeof draftRec.metadata === "string" ? JSON.parse(draftRec.metadata) : draftRec.metadata;
+          if (draftItem && typeof draftItem === "object") {
+            const recPkg = draftRec.package_id ?? void 0;
+            if (recPkg && draftItem._packageId === void 0) draftItem._packageId = recPkg;
+            draftItem._draft = true;
+          }
+          return { type: request.type, name: request.name, item: decorateMetadataItem(request.type, draftItem) };
+        }
+      } catch {
+      }
+    }
     try {
       const findOverlay = async (oid) => {
         const where = {
@@ -3818,6 +3884,37 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
       console.warn(`[Protocol] table sync failed for object '${name}': ${err?.message ?? err}`);
     }
   }
+  /**
+   * Inverse of {@link ensureObjectStorage}: drop an object's physical table.
+   * DESTRUCTIVE — deletes the table and all its rows. Only invoked when a
+   * delete explicitly opts into storage teardown (see {@link deleteMetaItem}'s
+   * `dropStorage`), so publishing an object solely to preview it can be undone
+   * without leaving an orphan table. Best-effort: a failure is logged, not
+   * thrown — the metadata delete already succeeded, and a stray table is
+   * reclaimed by the next sync/drop rather than blocking the delete.
+   */
+  async dropObjectStorage(type, name) {
+    if (type !== "object" && type !== "objects") return;
+    try {
+      await this.engine.dropObjectSchema(name);
+    } catch (err) {
+      console.warn(`[Protocol] table drop failed for object '${name}': ${err?.message ?? err}`);
+    }
+  }
+  /**
+   * Guard for storage teardown on delete. Drops a physical table only when
+   * the caller opted in AND it is safe: object types only (others have no
+   * table), active state only (drafts were never materialised), and never a
+   * `sys_`-prefixed platform table.
+   */
+  shouldDropStorage(type, name, dropStorage, state) {
+    if (!dropStorage) return false;
+    const singular = PLURAL_TO_SINGULAR3[type] ?? type;
+    if (singular !== "object") return false;
+    if (state !== "active") return false;
+    if (name.startsWith("sys_")) return false;
+    return true;
+  }
   async saveMetaItem(request) {
     if (!request.item) {
       throw new Error("Item data is required");
@@ -4198,6 +4295,100 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
       failed
     };
   }
+  /**
+   * Discard every pending DRAFT bound to a package — the NON-destructive
+   * inverse of {@link publishPackageDrafts}. Drops only `state='draft'` rows
+   * (via the per-item delete primitive), reverting the package to its last
+   * published baseline; active/published metadata and physical tables are
+   * left untouched.
+   *
+   * Use case: "I edited this app for a while and it turned out worse than
+   * before — abandon all my changes." Routes through the sys_metadata path
+   * (no metadata-service dependency, unlike `POST /packages/:id/revert`).
+   */
+  async discardPackageDrafts(request) {
+    await this.ensureOverlayIndex();
+    const orgId = request.organizationId ?? null;
+    const repo = this.getOverlayRepo(orgId);
+    const drafts = await repo.listDrafts({ packageId: request.packageId });
+    const discarded = [];
+    const failed = [];
+    for (const d of drafts) {
+      try {
+        await this.deleteMetaItem({
+          type: d.type,
+          name: d.name,
+          state: "draft",
+          ...request.organizationId ? { organizationId: request.organizationId } : {},
+          ...request.actor ? { actor: request.actor } : {}
+        });
+        discarded.push({ type: d.type, name: d.name });
+      } catch (e) {
+        failed.push({
+          type: d.type,
+          name: d.name,
+          error: e?.message ?? "discard failed",
+          ...e?.code ? { code: e.code } : {}
+        });
+      }
+    }
+    return {
+      success: failed.length === 0 && discarded.length > 0,
+      discardedCount: discarded.length,
+      failedCount: failed.length,
+      discarded,
+      failed
+    };
+  }
+  /**
+   * Delete an ENTIRE package: every `sys_metadata` row bound to it (active
+   * AND draft) and — by default — the physical table of each object it
+   * defined. DESTRUCTIVE: removes the app and its data. Use case: "I don't
+   * want this package anymore."
+   *
+   * Set `keepData: true` to remove the metadata but preserve object tables.
+   * The `sys_`-table guard in {@link deleteMetaItem} still applies, so
+   * platform storage is never dropped. Drafts are removed before active rows
+   * so each object's table is torn down once. Per-item failures are collected
+   * without aborting the rest.
+   */
+  async deletePackage(request) {
+    const where = { package_id: request.packageId };
+    if (request.organizationId) where.organization_id = request.organizationId;
+    const rows = await this.engine.find("sys_metadata", { where });
+    const dropStorage = request.keepData !== true;
+    const ordered = [...rows].sort((a, b) => (a.state === "draft" ? 0 : 1) - (b.state === "draft" ? 0 : 1));
+    const deleted = [];
+    const failed = [];
+    for (const row of ordered) {
+      const state = row.state === "draft" ? "draft" : "active";
+      try {
+        await this.deleteMetaItem({
+          type: row.type,
+          name: row.name,
+          state,
+          ...row.organization_id ? { organizationId: row.organization_id } : {},
+          ...request.actor ? { actor: request.actor } : {},
+          ...dropStorage ? { dropStorage: true } : {}
+        });
+        deleted.push({ type: row.type, name: row.name, state });
+      } catch (e) {
+        failed.push({
+          type: row.type,
+          name: row.name,
+          error: e?.message ?? "delete failed",
+          ...e?.code ? { code: e.code } : {}
+        });
+      }
+    }
+    return {
+      success: failed.length === 0 && deleted.length > 0,
+      deletedCount: deleted.length,
+      failedCount: failed.length,
+      deleted,
+      failed
+    };
+  }
   /**
    * Restore the body recorded at history `toVersion` as the new
    * live row. Writes a history event with `op='revert'`. 404
@@ -4430,6 +4621,9 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
           } catch {
           }
         }
+        if (this.shouldDropStorage(request.type, request.name, request.dropStorage, targetState)) {
+          await this.dropObjectStorage(singularTypeForRepo, request.name);
+        }
         await this.recordMetadataAudit({
           type: request.type,
           name: request.name,
@@ -4478,6 +4672,12 @@ var _ObjectStackProtocolImplementation = class _ObjectStackProtocolImplementatio
         };
       }
       await this.engine.delete("sys_metadata", { where: { id: existing.id } });
+      {
+        const targetState = request.state === "draft" ? "draft" : "active";
+        if (this.shouldDropStorage(request.type, request.name, request.dropStorage, targetState)) {
+          await this.dropObjectStorage(PLURAL_TO_SINGULAR3[request.type] ?? request.type, request.name);
+        }
+      }
       if (this.environmentId === void 0) {
         try {
           const services = this.getServicesRegistry?.();
@@ -4839,6 +5039,7 @@ _ObjectStackProtocolImplementation.RUNTIME_CREATE_ALLOWED_TYPES = (() => {
 var ObjectStackProtocolImplementation = _ObjectStackProtocolImplementation;
 
 // src/engine.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { ExecutionContextSchema } from "@objectstack/spec/kernel";
 import { createLogger } from "@objectstack/core";
 import { CoreServiceName, StorageNameMapping } from "@objectstack/spec/system";
@@ -5331,7 +5532,7 @@ function optionValues(options) {
   );
 }
 function validateOne(name, def, value) {
-  if (def.required && isMissing(value)) {
+  if (def.required && isMissing(value) && def.type !== "autonumber") {
     return { field: name, code: "required", message: `${name} is required` };
   }
   if (isMissing(value)) return null;
@@ -5429,8 +5630,31 @@ var ajv = new Ajv({ allErrors: true, strict: false });
 var jsonSchemaCache = /* @__PURE__ */ new WeakMap();
 function needsPriorRecord(objectSchema) {
   const rules = objectSchema?.validations;
-  if (!Array.isArray(rules)) return false;
-  return rules.some((r) => ruleNeedsPrior(r));
+  const ruleNeeds = Array.isArray(rules) && rules.some((r) => ruleNeedsPrior(r));
+  return !!(ruleNeeds || fieldsNeedPrior(objectSchema?.fields));
+}
+function stripReadonlyWhenFields(objectSchema, data, previous, logger) {
+  const fields = objectSchema?.fields;
+  if (!fields || !data) return data;
+  const merged = { ...previous ?? {}, ...data };
+  let result = data;
+  for (const [name, def] of Object.entries(fields)) {
+    if (!def?.readonlyWhen || !(name in data)) continue;
+    const res = ExpressionEngine2.evaluate(toExpression(def.readonlyWhen), {
+      record: merged,
+      previous: previous ?? void 0
+    });
+    if (!res.ok) {
+      logger?.warn?.(`readonlyWhen for '${name}' failed to evaluate \u2014 change allowed through`);
+      continue;
+    }
+    if (res.value === true) {
+      if (result === data) result = { ...data };
+      delete result[name];
+      logger?.warn?.(`Field '${name}' is read-only (readonlyWhen) \u2014 ignoring incoming change`);
+    }
+  }
+  return result;
 }
 function ruleNeedsPrior(r) {
   if (r == null || typeof r !== "object") return false;
@@ -5444,17 +5668,44 @@ function ruleNeedsPrior(r) {
   }
   return false;
 }
+function isMissing2(v) {
+  return v === void 0 || v === null || typeof v === "string" && v.trim() === "";
+}
+function fieldsNeedPrior(fields) {
+  if (!fields) return false;
+  return Object.values(fields).some(
+    (f) => f && (f.requiredWhen || f.conditionalRequired || f.readonlyWhen)
+  );
+}
 function toExpression(cond) {
   return typeof cond === "string" ? { dialect: "cel", source: cond } : cond;
 }
 function evaluateValidationRules(objectSchema, data, mode, opts = {}) {
+  if (!data) return;
   const rules = objectSchema?.validations;
-  if (!Array.isArray(rules) || rules.length === 0 || !data) return;
+  const hasRules = Array.isArray(rules) && rules.length > 0;
+  const fields = objectSchema?.fields;
+  const hasFieldRules = fieldsNeedPrior(fields);
+  if (!hasRules && !hasFieldRules) return;
   const previous = opts.previous ?? void 0;
   const merged = { ...previous ?? {}, ...data };
   const ctx = { data, merged, previous, mode, logger: opts.logger };
   const errors = [];
-  const ordered = rules.filter((r) => r != null && typeof r === "object").filter((r) => r.active !== false).filter((r) => {
+  if (hasFieldRules && fields) {
+    for (const [name, def] of Object.entries(fields)) {
+      const pred = def?.requiredWhen ?? def?.conditionalRequired;
+      if (!pred) continue;
+      const res = ExpressionEngine2.evaluate(toExpression(pred), { record: merged, previous });
+      if (!res.ok) {
+        opts.logger?.warn?.(`requiredWhen for '${name}' failed to evaluate \u2014 skipped`);
+        continue;
+      }
+      if (res.value === true && isMissing2(merged[name])) {
+        errors.push({ field: name, code: "required", message: `${name} is required` });
+      }
+    }
+  }
+  const ordered = (hasRules ? rules : []).filter((r) => r != null && typeof r === "object").filter((r) => r.active !== false).filter((r) => {
     const events = r.events ?? ["insert", "update"];
     return events.includes(mode);
   }).sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
@@ -5832,6 +6083,15 @@ function resolveMetadataItemName(key, item) {
 }
 var _ObjectQL = class _ObjectQL {
   constructor(hostContext = {}) {
+    /**
+     * Ambient transaction store (ADR-0034). While a `transaction()` callback
+     * runs, the active transaction handle lives here so that EVERY data
+     * operation — including internal reads done during a write (reference
+     * checks, hooks, expand) — automatically binds to the same connection
+     * instead of asking the pool for another one and deadlocking on the
+     * single-connection SQLite pool.
+     */
+    this.txStore = new AsyncLocalStorage();
     this.drivers = /* @__PURE__ */ new Map();
     this.defaultDriver = null;
     // Datasource mapping rules (imported from defineStack)
@@ -5873,6 +6133,12 @@ var _ObjectQL = class _ObjectQL {
     // getDriver()'s owner lookup would route CRUD to the wrong database. Each
     // engine now owns its registry so kernels are fully isolated.
     this._registry = new SchemaRegistry();
+    /** In-memory next-value cache per `object.field` for autonumber generation,
+     *  lazily seeded from the current max in the store. */
+    this.autonumberCounters = /* @__PURE__ */ new Map();
+    /** Lazily-built index: child object name → roll-up summary descriptors on
+     *  parent objects that aggregate it. Invalidated when packages register. */
+    this.summaryIndex = null;
     this.hostContext = hostContext;
     this.logger = hostContext.logger || createLogger({ level: "info", format: "pretty" });
     if (process?.env?.OBJECTQL_STRICT_HOOKS === "1") {
@@ -6175,13 +6441,14 @@ var _ObjectQL = class _ObjectQL {
    * mask the system path.
    */
   buildDriverOptions(execCtx, base) {
-    const hasTx = execCtx?.transaction !== void 0;
+    const tx = execCtx?.transaction !== void 0 ? execCtx.transaction : this.txStore.getStore()?.transaction;
+    const hasTx = tx !== void 0;
     const hasTenant = execCtx?.tenantId !== void 0;
     const isSystem = execCtx?.isSystem === true;
     if (!hasTx && !hasTenant && !isSystem) return base;
     const opts = base && typeof base === "object" ? { ...base } : {};
     if (hasTx && opts.transaction === void 0) {
-      opts.transaction = execCtx.transaction;
+      opts.transaction = tx;
     }
     if (hasTenant && opts.tenantId === void 0) {
       opts.tenantId = execCtx.tenantId;
@@ -6247,6 +6514,66 @@ var _ObjectQL = class _ObjectQL {
     }
     return out;
   }
+  /**
+   * Generate values for empty `autonumber` fields on insert — ONLY for drivers
+   * that do not generate them natively (memory, mongodb). For SQL-backed objects
+   * the driver owns a persistent, atomic `_objectstack_sequences` table and
+   * advertises `supports.autonumber === true`; the engine then defers entirely
+   * and never pre-fills (so the persistent sequence is the single source of
+   * truth — see #1603). Required-validation exempts `autonumber` either way, so
+   * a `required` record number is never rejected for "missing" — the runtime
+   * owns the value, not the client.
+   *
+   * In the fallback path the next value is `max(existing) + 1`, seeded once per
+   * `object.field` from the store then incremented in memory (monotonic within
+   * the process, resilient to deletions). `autonumberFormat` is honored, e.g.
+   * `CASE-{0000}` → `CASE-0042`. NOTE: this in-memory seeding is single-instance.
+   */
+  async applyAutonumbers(object, record, execCtx, driverOwnsAutonumber) {
+    if (driverOwnsAutonumber) return;
+    const fields = this.getSchema(object)?.fields;
+    if (!fields || typeof fields !== "object" || Array.isArray(fields)) return;
+    for (const [name, def] of Object.entries(fields)) {
+      if (def?.type !== "autonumber") continue;
+      const current = record[name];
+      if (current != null && current !== "") continue;
+      const key = `${object}.${name}`;
+      let next = this.autonumberCounters.get(key);
+      if (next == null) next = await this.seedAutonumber(object, name, execCtx);
+      next += 1;
+      this.autonumberCounters.set(key, next);
+      const fmt = def.autonumberFormat ?? def.format;
+      record[name] = this.formatAutonumber(fmt, next);
+    }
+  }
+  /** Seed the autonumber counter from the current max numeric value in store. */
+  async seedAutonumber(object, field, execCtx) {
+    try {
+      const rows = await this.find(object, {
+        select: ["id", field],
+        limit: 5e3,
+        context: execCtx
+      });
+      let max = 0;
+      for (const r of rows || []) {
+        const v = r?.[field];
+        if (v == null) continue;
+        const m = String(v).match(/(\d+)(?!.*\d)/);
+        if (m) max = Math.max(max, parseInt(m[1], 10) || 0);
+      }
+      return max;
+    } catch {
+      return 0;
+    }
+  }
+  /** Apply an autonumber format like `CASE-{0000}`; default to the bare number. */
+  formatAutonumber(format, value) {
+    if (!format) return String(value);
+    const m = format.match(/\{(0+)\}/);
+    if (!m) return format.includes("{0}") ? format.replace("{0}", String(value)) : `${format}${value}`;
+    const padded = String(value).padStart(m[1].length, "0");
+    return format.replace(m[0], padded);
+  }
   /**
    * Register contribution (Manifest)
    * 
@@ -6260,6 +6587,7 @@ var _ObjectQL = class _ObjectQL {
   registerApp(manifest) {
     const id = manifest.id || manifest.name;
     const namespace = manifest.namespace;
+    this.invalidateSummaryIndex();
     this.logger.debug("Registering package manifest", { id, namespace });
     console.warn(`[ObjectQL:registerApp] id=${id} flows=${Array.isArray(manifest.flows) ? manifest.flows.length : typeof manifest.flows} keys=${Object.keys(manifest).join(",")}`);
     if (id) {
@@ -6340,6 +6668,7 @@ var _ObjectQL = class _ObjectQL {
       "pages",
       "dashboards",
       "reports",
+      "datasets",
       "themes",
       // Automation Protocol
       "flows",
@@ -6484,6 +6813,7 @@ var _ObjectQL = class _ObjectQL {
       "pages",
       "dashboards",
       "reports",
+      "datasets",
       "themes",
       "flows",
       "workflows",
@@ -6865,6 +7195,102 @@ var _ObjectQL = class _ObjectQL {
     }
     this.logger.info("ObjectQL engine destroyed");
   }
+  /** Invalidate the cached roll-up summary index (call when metadata changes). */
+  invalidateSummaryIndex() {
+    this.summaryIndex = null;
+  }
+  /** Scan all registered objects for `summary` fields and index them by the
+   *  child object they aggregate, resolving the child→parent FK field. */
+  buildSummaryIndex() {
+    const index = /* @__PURE__ */ new Map();
+    let objects = [];
+    try {
+      objects = this._registry.getAllObjects?.() ?? [];
+    } catch {
+      objects = [];
+    }
+    for (const parent of objects) {
+      const fields = parent?.fields;
+      if (!fields || typeof fields !== "object" || Array.isArray(fields)) continue;
+      for (const [summaryField, def] of Object.entries(fields)) {
+        const d = def;
+        if (d?.type !== "summary" || !d.summaryOperations) continue;
+        const so = d.summaryOperations;
+        const childObject = so.object;
+        const fn = so.function;
+        if (!childObject || !fn) continue;
+        let fkField = so.relationshipField;
+        if (!fkField) {
+          const child = this._registry.getObject(childObject);
+          const cfields = child?.fields || {};
+          for (const [cfName, cdef] of Object.entries(cfields)) {
+            const cd = cdef;
+            if ((cd?.type === "master_detail" || cd?.type === "lookup") && cd?.reference === parent.name) {
+              fkField = cfName;
+              break;
+            }
+          }
+        }
+        if (!fkField) continue;
+        const list = index.get(childObject) ?? [];
+        list.push({ parentObject: parent.name, summaryField, fkField, fn, sourceField: so.field });
+        index.set(childObject, list);
+      }
+    }
+    return index;
+  }
+  getSummaryDescriptors(childObject) {
+    if (!this.summaryIndex) this.summaryIndex = this.buildSummaryIndex();
+    return this.summaryIndex.get(childObject) ?? [];
+  }
+  /**
+   * Recompute roll-up `summary` fields on parent records after a child write.
+   * For each affected parent (the FK value on the changed/old child record), it
+   * aggregates the child collection and writes the result onto the parent's
+   * summary field. Runs in the caller's execution context so it joins the same
+   * transaction (e.g. the cross-object batch) when one is open.
+   */
+  async recomputeSummaries(childObject, records, previous, execCtx) {
+    const descriptors = this.getSummaryDescriptors(childObject);
+    if (descriptors.length === 0) return;
+    const recs = Array.isArray(records) ? records : records ? [records] : [];
+    const prevs = Array.isArray(previous) ? previous : previous ? [previous] : [];
+    for (const desc of descriptors) {
+      const ids = /* @__PURE__ */ new Set();
+      for (const r of recs) {
+        const v = r?.[desc.fkField];
+        if (v != null && v !== "") ids.add(String(v));
+      }
+      for (const p of prevs) {
+        const v = p?.[desc.fkField];
+        if (v != null && v !== "") ids.add(String(v));
+      }
+      for (const parentId of ids) {
+        try {
+          const rows = await this.aggregate(childObject, {
+            where: { [desc.fkField]: parentId },
+            aggregations: [{
+              function: desc.fn,
+              ...desc.fn === "count" ? {} : { field: desc.sourceField },
+              alias: "value"
+            }],
+            context: execCtx
+          });
+          let value = rows?.[0]?.value;
+          if (value == null) value = desc.fn === "count" || desc.fn === "sum" ? 0 : null;
+          await this.update(desc.parentObject, { id: parentId, [desc.summaryField]: value }, { context: execCtx });
+        } catch (err) {
+          this.logger.warn("Roll-up summary recompute failed", {
+            childObject,
+            parentObject: desc.parentObject,
+            parentId,
+            field: desc.summaryField,
+            error: err?.message
+          });
+        }
+      }
+    }
+  }
   /**
    * Post-process expand: resolve lookup/master_detail fields by batch-loading related records.
    * 
@@ -7080,10 +7506,14 @@ var _ObjectQL = class _ObjectQL {
         let result;
         const nowSnap = /* @__PURE__ */ new Date();
         const schemaForValidation = this._registry.getObject(object);
+        const driverOwnsAutonumber = driver?.supports?.autonumber === true;
         if (Array.isArray(hookContext.input.data)) {
           const rows = hookContext.input.data.map(
             (row) => this.applyFieldDefaults(object, row, opCtx.context, nowSnap)
           );
+          for (const r of rows) {
+            await this.applyAutonumbers(object, r, opCtx.context, driverOwnsAutonumber);
+          }
           for (const r of rows) {
             await this.encryptSecretFields(object, r, opCtx.context, hookContext.input.options);
           }
@@ -7103,6 +7533,7 @@ var _ObjectQL = class _ObjectQL {
             opCtx.context,
             nowSnap
           );
+          await this.applyAutonumbers(object, row, opCtx.context, driverOwnsAutonumber);
           await this.encryptSecretFields(object, row, opCtx.context, hookContext.input.options);
           validateRecord(schemaForValidation, row, "insert");
           evaluateValidationRules(schemaForValidation, row, "insert", { logger: this.logger });
@@ -7111,6 +7542,7 @@ var _ObjectQL = class _ObjectQL {
         hookContext.event = "afterInsert";
         hookContext.result = result;
         await this.triggerHooks("afterInsert", hookContext);
+        await this.recomputeSummaries(object, result, null, opCtx.context);
         if (this.realtimeService) {
           try {
             if (Array.isArray(result)) {
@@ -7195,6 +7627,7 @@ var _ObjectQL = class _ObjectQL {
             const priorAst = { object, where: { id: hookContext.input.id }, limit: 1 };
             priorRecord = await driver.findOne(object, priorAst, hookContext.input.options);
           }
+          hookContext.input.data = stripReadonlyWhenFields(updateSchema, hookContext.input.data, priorRecord, this.logger);
           evaluateValidationRules(updateSchema, hookContext.input.data, "update", { previous: priorRecord, logger: this.logger });
           result = await driver.update(object, hookContext.input.id, hookContext.input.data, hookContext.input.options);
         } else if (options?.multi && driver.updateMany) {
@@ -7212,6 +7645,7 @@ var _ObjectQL = class _ObjectQL {
         hookContext.result = result;
         if (priorRecord) hookContext.previous = priorRecord;
         await this.triggerHooks("afterUpdate", hookContext);
+        await this.recomputeSummaries(object, result, priorRecord, opCtx.context);
         if (this.realtimeService) {
           try {
             const resultId = typeof result === "object" && result && "id" in result ? result.id : void 0;
@@ -7240,6 +7674,66 @@ var _ObjectQL = class _ObjectQL {
     });
     return opCtx.result;
   }
+  /**
+   * Apply referential delete behavior for relations pointing AT this record,
+   * before it is removed. For every registered object with a `master_detail`
+   * or `lookup` field referencing `object`, honor the field's `deleteBehavior`:
+   *   - `cascade`  → delete the dependent rows (recursively, so grandchildren
+   *                  are handled by each child's own delete),
+   *   - `set_null` → clear the foreign key,
+   *   - `restrict` → refuse the delete when dependents exist.
+   * `master_detail` defaults to `cascade` (the parent owns the child
+   * lifecycle); `lookup` defaults to `set_null`. Only runs for single-id
+   * deletes — multi/predicate deletes skip cascade (logged).
+   */
+  async cascadeDeleteRelations(object, id, context, depth = 0) {
+    if (id == null || depth >= _ObjectQL.MAX_CASCADE_DEPTH) return;
+    let objects;
+    try {
+      objects = this._registry.getAllObjects();
+    } catch {
+      return;
+    }
+    for (const child of objects) {
+      const childName = child?.name;
+      const fields = child?.fields;
+      if (!childName || !fields) continue;
+      for (const [fieldName, fdef] of Object.entries(fields)) {
+        if (!fdef || fdef.type !== "master_detail" && fdef.type !== "lookup") continue;
+        const ref = fdef.reference;
+        if (!ref) continue;
+        let resolvedRef;
+        try {
+          resolvedRef = this.resolveObjectName(ref);
+        } catch {
+          resolvedRef = void 0;
+        }
+        if (ref !== object && resolvedRef !== object) continue;
+        const behavior = fdef.type === "master_detail" ? fdef.deleteBehavior === "restrict" ? "restrict" : "cascade" : fdef.deleteBehavior || "set_null";
+        let dependents;
+        try {
+          dependents = await this.find(childName, { where: { [fieldName]: id }, context });
+        } catch {
+          continue;
+        }
+        if (!dependents || dependents.length === 0) continue;
+        if (behavior === "restrict") {
+          throw new Error(
+            `Cannot delete ${object} (${id}): ${dependents.length} dependent ${childName} record(s) via ${fieldName}`
+          );
+        }
+        for (const dep of dependents) {
+          const depId = dep?.id;
+          if (depId == null) continue;
+          if (behavior === "cascade") {
+            await this.delete(childName, { where: { id: depId }, context });
+          } else {
+            await this.update(childName, { id: depId, [fieldName]: null }, { context });
+          }
+        }
+      }
+    }
+  }
   async delete(object, options) {
     object = this.resolveObjectName(object);
     this.logger.debug("Delete operation starting", { object });
@@ -7269,7 +7763,15 @@ var _ObjectQL = class _ObjectQL {
       hookContext.input.options = this.buildDriverOptions(opCtx.context, hookContext.input.options);
       try {
         let result;
+        let summaryPrev = null;
+        if (hookContext.input.id && this.getSummaryDescriptors(object).length > 0) {
+          try {
+            summaryPrev = await this.findOne(object, { where: { id: hookContext.input.id }, context: opCtx.context });
+          } catch {
+          }
+        }
         if (hookContext.input.id) {
+          await this.cascadeDeleteRelations(object, hookContext.input.id, opCtx.context);
           result = await driver.delete(object, hookContext.input.id, hookContext.input.options);
         } else if (options?.multi && driver.deleteMany) {
           const ast = { object, where: options.where };
@@ -7280,6 +7782,7 @@ var _ObjectQL = class _ObjectQL {
         hookContext.event = "afterDelete";
         hookContext.result = result;
         await this.triggerHooks("afterDelete", hookContext);
+        if (summaryPrev) await this.recomputeSummaries(object, null, summaryPrev, opCtx.context);
         if (this.realtimeService) {
           try {
             const resultId = typeof result === "object" && result && "id" in result ? result.id : void 0;
@@ -7429,7 +7932,7 @@ var _ObjectQL = class _ObjectQL {
     const trx = await drv.beginTransaction();
     const trxCtx = { ...baseContext ?? {}, transaction: trx };
     try {
-      const result = await callback(trxCtx);
+      const result = await this.txStore.run({ transaction: trx }, () => callback(trxCtx));
       if (drv.commit) await drv.commit(trx);
       else if (drv.commitTransaction) await drv.commitTransaction(trx);
       return result;
@@ -7579,6 +8082,22 @@ var _ObjectQL = class _ObjectQL {
     const tableName = StorageNameMapping.resolveTableName(obj);
     await driver.syncSchema(tableName, obj);
   }
+  /**
+   * Drop the physical storage (table/collection) backing an object — the
+   * inverse of {@link syncObjectSchema}. DESTRUCTIVE: deletes all rows in the
+   * table. Used by the protocol delete path when the caller explicitly opts
+   * into storage teardown (e.g. discarding an object that was published only
+   * to preview it). No-op when the object's driver does not expose `dropTable`.
+   * Resolves the physical table name from the registered definition, falling
+   * back to the bare name if the def was already removed.
+   */
+  async dropObjectSchema(objectName) {
+    const obj = this._registry.getObject(objectName);
+    const driver = this.getDriverForObject(objectName);
+    if (!driver || typeof driver.dropTable !== "function") return;
+    const tableName = StorageNameMapping.resolveTableName(obj ?? { name: objectName });
+    await driver.dropTable(tableName);
+  }
   /**
    * Get a registered driver by datasource name.
    * Alias matching @objectql/core datasource() API.
@@ -7677,6 +8196,7 @@ var _ObjectQL = class _ObjectQL {
 // ============================================
 /** Maximum depth for recursive expand to prevent infinite loops */
 _ObjectQL.MAX_EXPAND_DEPTH = 3;
+_ObjectQL.MAX_CASCADE_DEPTH = 10;
 var ObjectQL = _ObjectQL;
 var ObjectRepository = class {
   constructor(objectName, context, engine) {
@@ -7794,8 +8314,10 @@ var ScopedContext = class _ScopedContext {
       { ...this.executionContext, transaction: trx },
       this.engine
     );
+    const txStore = this.engine?.txStore;
+    const runIn = (fn) => txStore ? txStore.run({ transaction: trx }, fn) : fn();
     try {
-      const result = await callback(trxCtx);
+      const result = await runIn(() => callback(trxCtx));
       if (driver.commit) await driver.commit(trx);
       else if (driver.commitTransaction) await driver.commitTransaction(trx);
       return result;