@objectstack/objectql 9.9.0 → 9.10.0

package/dist/index.mjs

@@ -141,7 +141,10 @@ var init_seed_loader = __esm({
         const seedIdentity = config.identity;
         const baseEvalCtx = {
           now: seedNow,
-          user: seedIdentity?.user,
+          // `id: null` is a legitimate seed-time state (the owning admin does not
+          // exist yet) that the formula EvalContext's `user.id: string` type does
+          // not yet model — cast the fallback so `os.user.id` evaluates to null.
+          user: seedIdentity?.user ?? { id: null },
           // Fall back to the per-tenant organizationId so `os.org.id` resolves
           // during per-org replay even without an explicit identity.org.
           org: seedIdentity?.org ?? (config.organizationId ? { id: config.organizationId } : void 0),
@@ -161,7 +164,7 @@ var init_seed_loader = __esm({
               targetField: "(expression)",
               attemptedValue: dataset.records[i],
               recordIndex: i,
-              message: `Cannot resolve dynamic seed values for ${objectName} record #${i}: ${seedResult.error.message}. Records using cel\`os.user.id\` / cel\`os.org.id\` require a seed identity \u2014 ensure a system/admin user exists before seeding (see SeedLoaderConfig.identity).`
+              message: `Cannot resolve dynamic seed values for ${objectName} record #${i}: ${seedResult.error.message}. \`os.user.id\` resolves to null at seed time (the owning admin does not exist yet) and owner-style fields are assigned by the first-admin handoff \u2014 so a required, non-owner field must not depend on it. Provide a literal value or make the field optional.`
             };
             errors.push(error);
             allErrors.push(error);
@@ -840,6 +843,8 @@ function applySystemFields(schema, opts) {
   const tenancyDisabled = schema.tenancy?.enabled === false;
   const wantTenant = sf?.tenant !== false && !tenancyDisabled;
   const wantAudit = sf?.audit !== false;
+  const ownership = schema.ownership;
+  const wantOwner = ownership !== "org" && ownership !== "none" && !schema.managedBy && !schema.name.startsWith("sys_");
   const additions = {};
   if (wantTenant && !schema.fields?.organization_id) {
     additions.organization_id = {
@@ -898,6 +903,17 @@ function applySystemFields(schema, opts) {
       };
     }
   }
+  if (wantOwner && !schema.fields?.owner_id) {
+    additions.owner_id = {
+      type: "lookup",
+      reference: "sys_user",
+      label: "Owner",
+      required: false,
+      readonly: false,
+      system: true,
+      description: "Record owner (auto-stamped to the creating user on insert; reassignable). Drives owner-scoped views, reports and notifications."
+    };
+  }
   if (Object.keys(additions).length === 0) return schema;
   return {
     ...schema,
@@ -7025,7 +7041,7 @@ function aggregateBucket(rows, aggregations) {
     const alias = agg.alias;
     const fn = agg.function;
     if (fn === "count") {
-      if (!agg.field) {
+      if (!agg.field || agg.field === "*") {
         out[alias] = rows.length;
       } else {
         out[alias] = rows.reduce(
@@ -9448,6 +9464,58 @@ var ScopedContext = class _ScopedContext {
       throw error;
     }
   }
+  /**
+   * Resolve the default driver, if it exposes transaction primitives.
+   * Shared by {@link transaction} and the discrete begin/commit/rollback trio.
+   */
+  txDriver() {
+    const engine = this.engine;
+    const driver = engine.defaultDriver ? engine.drivers?.get(engine.defaultDriver) : void 0;
+    return driver?.beginTransaction ? driver : void 0;
+  }
+  /**
+   * Discrete transaction primitives — `begin` / `commit` / `rollback` as three
+   * separate calls, in contrast to {@link transaction}'s single-callback form.
+   *
+   * This trio exists for callers that cannot keep a JS closure on the stack for
+   * the lifetime of the transaction — chiefly the sandbox runner, where the
+   * hook/action body's `ctx.api.transaction(fn)` is driven across many host
+   * event-loop turns via deferred promises. Across those `setImmediate`
+   * boundaries the engine's ambient `txStore` (AsyncLocalStorage) does NOT
+   * survive, so the transaction handle is threaded **explicitly**: `begin`
+   * returns a child ScopedContext carrying `transaction: trx` in its execution
+   * context, and `resolveTx` honors that explicit handle ahead of the ambient
+   * store. Every `object(...)` op on the returned context therefore reuses the
+   * one connection without relying on ALS.
+   *
+   * Returns `null` when the driver has no transaction support — the caller then
+   * runs non-transactionally against `this` (same graceful degrade as
+   * {@link transaction}).
+   */
+  async beginTransaction() {
+    const driver = this.txDriver();
+    if (!driver) return null;
+    const trx = await driver.beginTransaction();
+    const ctx = new _ScopedContext(
+      { ...this.executionContext, transaction: trx },
+      this.engine
+    );
+    return { ctx, handle: trx };
+  }
+  /** Commit a handle obtained from {@link beginTransaction}. */
+  async commitTransaction(handle) {
+    const driver = this.txDriver();
+    if (!driver) return;
+    if (driver.commit) await driver.commit(handle);
+    else if (driver.commitTransaction) await driver.commitTransaction(handle);
+  }
+  /** Roll back a handle obtained from {@link beginTransaction}. */
+  async rollbackTransaction(handle) {
+    const driver = this.txDriver();
+    if (!driver) return;
+    if (driver.rollback) await driver.rollback(handle);
+    else if (driver.rollbackTransaction) await driver.rollbackTransaction(handle);
+  }
   get userId() {
     return this.executionContext.userId;
   }