webspresso 0.0.89 → 0.0.91

package/core/orm/events.js

@@ -1,6 +1,6 @@
 /**
  * Webspresso ORM - Events/Signals System
- * Django-style signal system for model lifecycle events
+ * Django-style signal system for model lifecycle events with leak detection and maxListeners bounds
  * @module core/orm/events
  */
 
@@ -16,6 +16,7 @@
  */
 
 const EMPTY_ARRAY = Object.freeze([]);
+const DEFAULT_MAX_LISTENERS = 50;
 
 function cancelContext(reason = 'Operation cancelled') {
   this.isCancelled = true;
@@ -42,12 +43,34 @@ function createEventContext(model, operation, trx = null) {
 
 /**
  * ModelEvents - Global event bus for ORM lifecycle events
- * Singleton class that manages event listeners and emission
+ * Singleton class that manages event listeners, emission, and memory leak warnings
  */
 class ModelEventsClass {
   constructor() {
     /** @type {Map<string, Set<Function>>} */
     this.listeners = new Map();
+    this.maxListeners = DEFAULT_MAX_LISTENERS;
+  }
+
+  /**
+   * Set maximum number of listeners allowed per event before warning
+   * @param {number} n
+   * @returns {this}
+   */
+  setMaxListeners(n) {
+    if (typeof n !== 'number' || n < 0 || Number.isNaN(n)) {
+      throw new TypeError('The value of "n" must be a non-negative number');
+    }
+    this.maxListeners = n;
+    return this;
+  }
+
+  /**
+   * Get current maximum listeners threshold
+   * @returns {number}
+   */
+  getMaxListeners() {
+    return this.maxListeners;
   }
 
   /**
@@ -64,7 +87,19 @@ class ModelEventsClass {
     if (!this.listeners.has(event)) {
       this.listeners.set(event, new Set());
     }
-    this.listeners.get(event).add(callback);
+
+    const set = this.listeners.get(event);
+    set.add(callback);
+
+    // Memory leak detection & warning
+    if (this.maxListeners > 0 && set.size > this.maxListeners) {
+      const warnMsg = `Possible ModelEvents memory leak detected. ${set.size} '${event}' listeners added. Use setMaxListeners() to increase limit.`;
+      if (typeof process !== 'undefined' && typeof process.emitWarning === 'function') {
+        process.emitWarning(warnMsg, 'MaxListenersExceededWarning');
+      } else {
+        console.warn(`[webspresso:warning] ${warnMsg}`);
+      }
+    }
 
     // Return unsubscribe function
     return () => this.off(event, callback);
@@ -84,6 +119,27 @@ class ModelEventsClass {
     return this.on(event, wrapper);
   }
 
+  /**
+   * Attach a listener scoped to an HTTP request or lifecycle target (auto-removes on finish/close)
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   * @param {Object} [lifecycleTarget] - Optional target with on/once (e.g. Express `res` or `req`)
+   * @returns {Function} Unsubscribe function
+   */
+  listenScoped(event, callback, lifecycleTarget) {
+    const unsubscribe = this.on(event, callback);
+
+    if (lifecycleTarget && typeof lifecycleTarget.once === 'function') {
+      const cleanup = () => {
+        unsubscribe();
+      };
+      lifecycleTarget.once('finish', cleanup);
+      lifecycleTarget.once('close', cleanup);
+    }
+
+    return unsubscribe;
+  }
+
   /**
    * Remove an event listener
    * @param {string} event - Event name
@@ -93,7 +149,11 @@ class ModelEventsClass {
   off(event, callback) {
     const listeners = this.listeners.get(event);
     if (listeners) {
-      return listeners.delete(callback);
+      const removed = listeners.delete(callback);
+      if (listeners.size === 0) {
+        this.listeners.delete(event);
+      }
+      return removed;
     }
     return false;
   }
@@ -227,16 +287,6 @@ class ModelEventsClass {
     return ctx;
   }
 
-  /**
-   * Check if there are any listeners for an event
-   * @param {string} model - Model name
-   * @param {string} hook - Hook name
-   * @returns {boolean}
-   */
-  hasListeners(model, hook) {
-    return this.getMatchingListeners(model, hook).length > 0;
-  }
-
   /**
    * Get listener count for an event
    * @param {string} [event] - Specific event (optional)

package/core/orm/index.js

@@ -16,6 +16,14 @@ const { ModelEvents, Hooks, HookCancellationError, createEventContext } = requir
 const { omitHiddenColumns, sanitizeForOutput } = require('./utils');
 const { generateNanoid, zodNanoid, extendZ } = require('./utils/nanoid');
 const { createOrmCacheFromConfig, unregisterOrmCacheListeners } = require('./cache');
+const {
+  ambientTransactionStorage,
+  runWithAmbientTransaction,
+  getAmbientTransaction,
+  hasAmbientTransaction,
+  createTransactionContext,
+  runTransaction,
+} = require('./transaction');
 
 /**
  * Create a database instance
@@ -128,10 +136,14 @@ function createDatabase(config) {
 
   /**
    * Get a model by name
-   * @param {string} name - Model name
+   * @param {string|import('./types').ModelDefinition} nameOrModel - Model name or model definition
    * @returns {import('./types').ModelDefinition}
    */
-  function getModelInstance(name) {
+  function getModelInstance(nameOrModel) {
+    const name = typeof nameOrModel === 'object' && nameOrModel !== null && nameOrModel.name
+      ? nameOrModel.name
+      : nameOrModel;
+
     // First check local registry
     let model = models.get(name);
     
@@ -221,26 +233,34 @@ function createDatabase(config) {
   }
 
   /**
-   * Run operations in a transaction
+   * Run operations in an ambient transaction
    * @param {Function} callback - Callback receiving transaction context
+   * @param {import('./types').ScopeContext} [scopeContext] - Optional scope context
    * @returns {Promise<*>} Result of callback
    */
-  async function transaction(callback) {
+  async function transaction(callback, scopeContext) {
     return knexInstance.transaction(async (trx) => {
-      // Create transaction context with repository methods
       const trxContext = {
         trx,
-        getRepository(modelName, scopeContext) {
+        getRepository(modelName, sContext) {
           const model = getModelInstance(modelName);
-          const ctx = scopeContext || createScopeContext();
+          const ctx = sContext || scopeContext || createScopeContext();
           return createRepository(model, trx, ctx, ormCacheLayer);
         },
-        createRepository(model, scopeContext) {
-          const ctx = scopeContext || createScopeContext();
+        createRepository(model, sContext) {
+          const ctx = sContext || scopeContext || createScopeContext();
           return createRepository(model, trx, ctx, ormCacheLayer);
         },
+        forTenant(tenantId) {
+          if (!scopeContext) scopeContext = createScopeContext();
+          scopeContext.tenantId = tenantId;
+          return this;
+        },
+        getScopeContext() {
+          return { ...(scopeContext || createScopeContext()) };
+        },
       };
-      return callback(trxContext);
+      return runWithAmbientTransaction(trx, () => callback(trxContext));
     });
   }
 
@@ -255,6 +275,9 @@ function createDatabase(config) {
     createRepository: createRepositoryFromModel,
     query,
     transaction,
+    runInTransaction: transaction,
+    getAmbientTransaction,
+    hasActiveTransaction: hasAmbientTransaction,
     createSeeder: createSeederInstance,
     cache: ormCachePublicApi,
     destroy: () => {
@@ -275,6 +298,13 @@ module.exports = {
   createMemoryCacheProvider: require('./cache/memory-provider').createMemoryCacheProvider,
   OrmCacheLayer: require('./cache/layer').OrmCacheLayer,
   createOrmCacheFromConfig: require('./cache').createOrmCacheFromConfig,
+  // Ambient transaction management
+  ambientTransactionStorage,
+  runWithAmbientTransaction,
+  getAmbientTransaction,
+  hasAmbientTransaction,
+  createTransactionContext,
+  runTransaction,
   // Schema helpers
   zdb,
   createSchemaHelpers,
@@ -298,4 +328,9 @@ module.exports = {
   Hooks,
   HookCancellationError,
   createEventContext,
+  // Query Complexity & DoS Protection
+  QueryComplexityError: require('./complexity').QueryComplexityError,
+  validateQueryComplexity: require('./complexity').validateQueryComplexity,
+  resolveQueryLimits: require('./complexity').resolveQueryLimits,
+  DEFAULT_QUERY_LIMITS: require('./complexity').DEFAULT_QUERY_LIMITS,
 };

package/core/orm/model.js

@@ -31,6 +31,7 @@ function defineModel(options) {
     rest = {},
     hooks = {},
     hidden = [],
+    queryLimits = {},
     cache: cacheOption,
   } = options;
 
@@ -54,6 +55,7 @@ function defineModel(options) {
   const columns = extractColumnsFromSchema(schema);
 
   // Validate relations
+  const normalizedRelations = {};
   for (const [relationName, relation] of Object.entries(relations)) {
     if (!['belongsTo', 'hasMany', 'hasOne'].includes(relation.type)) {
       throw new Error(
@@ -70,6 +72,8 @@ function defineModel(options) {
         `Relation "${relationName}" in model "${name}" must have a foreignKey string`
       );
     }
+
+    normalizedRelations[relationName] = relation;
   }
 
   // Create model definition
@@ -78,7 +82,7 @@ function defineModel(options) {
     table,
     schema,
     primaryKey,
-    relations,
+    relations: normalizedRelations,
     scopes: {
       softDelete: scopes.softDelete || false,
       timestamps: scopes.timestamps || false,
@@ -102,6 +106,7 @@ function defineModel(options) {
       allowInclude: Array.isArray(rest.allowInclude) ? rest.allowInclude.filter((x) => typeof x === 'string') : null,
     },
     hidden: Array.isArray(hidden) ? hidden : [],
+    queryLimits: typeof queryLimits === 'object' && queryLimits !== null ? queryLimits : {},
     hooks: {},
     cache: cacheOption,
   };
@@ -186,7 +191,10 @@ function unregisterModel(name) {
  * @returns {import('./types').ModelDefinition}
  */
 function resolveRelationModel(relation) {
-  const model = relation.model();
+  let model = typeof relation.model === 'function' ? relation.model() : relation.model;
+  if (typeof model === 'string') {
+    model = getModel(model);
+  }
   if (!model || !model.name) {
     throw new Error('Invalid relation model reference');
   }

package/core/orm/query-builder.js

@@ -13,6 +13,8 @@ const {
   serializeJsonFields,
   deserializeJsonFields,
 } = require('./json-fields');
+const { getAmbientTransaction } = require('./transaction');
+const { validateQueryComplexity } = require('./complexity');
 
 /**
  * Create a new query builder
@@ -236,7 +238,8 @@ class QueryBuilder {
    * @returns {this}
    */
   limit(limit) {
-    this.state.limitValue = limit;
+    const validated = validateQueryComplexity(this.model, { limit });
+    this.state.limitValue = validated.limit;
     return this;
   }
 
@@ -256,7 +259,9 @@ class QueryBuilder {
    * @returns {this}
    */
   with(...relations) {
-    this.state.withs.push(...relations.flat());
+    const flat = relations.flat();
+    const validated = validateQueryComplexity(this.model, { includes: [...this.state.withs, ...flat] });
+    this.state.withs = validated.includes;
     return this;
   }
 
@@ -288,12 +293,28 @@ class QueryBuilder {
     return this;
   }
 
+  /**
+   * Resolve active Knex instance (explicit or ambient transaction)
+   * @returns {import('knex').Knex|import('knex').Knex.Transaction}
+   */
+  getActiveKnex() {
+    if (this.knex && (this.knex.isTransaction || typeof this.knex.commit === 'function')) {
+      return this.knex;
+    }
+    const ambientTrx = getAmbientTransaction();
+    if (ambientTrx) {
+      return ambientTrx;
+    }
+    return this.knex;
+  }
+
   /**
    * Transaction handle for lifecycle hooks (matches repository pattern)
    * @returns {import('knex').Knex.Transaction|null}
    */
   _hookTrx() {
-    return this.knex.isTransaction ? this.knex : null;
+    const active = this.getActiveKnex();
+    return (active && (active.isTransaction || typeof active.commit === 'function')) ? active : null;
   }
 
   /**
@@ -304,7 +325,8 @@ class QueryBuilder {
    */
   toKnex(options = {}) {
     const { includeLimitOffset = true } = options;
-    let qb = this.knex(this.model.table);
+    const activeKnex = this.getActiveKnex();
+    let qb = activeKnex(this.model.table);
 
     // Apply global scopes
     qb = applyScopes(qb, this.scopeContext, this.model);
@@ -564,6 +586,10 @@ class QueryBuilder {
    * @returns {Promise<import('./types').PaginatedResult>}
    */
   async paginate(page = 1, perPage = 15) {
+    const validated = validateQueryComplexity(this.model, { perPage });
+    perPage = validated.perPage;
+    page = Math.max(1, parseInt(page, 10) || 1);
+
     const ctx = createEventContext(this.model.name, 'find', this._hookTrx());
     const self = this;
 

package/core/orm/repository.js

@@ -16,6 +16,7 @@ const {
 const { ensureArray } = require('./utils');
 const { ModelEvents, createEventContext, Hooks, HookCancellationError } = require('./events');
 const { getJsonColumns, serializeJsonFields, deserializeJsonFields } = require('./json-fields');
+const { getAmbientTransaction } = require('./transaction');
 
 /**
  * Create a repository for a model
@@ -30,12 +31,37 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
   const jsonColumns = getJsonColumns(model);
   const hasJson = jsonColumns.size > 0;
 
+  /**
+   * Resolve active Knex instance (explicit or ambient transaction)
+   * @returns {import('knex').Knex|import('knex').Knex.Transaction}
+   */
+  function getActiveKnex() {
+    if (knex && (knex.isTransaction || typeof knex.commit === 'function')) {
+      return knex;
+    }
+    const ambientTrx = getAmbientTransaction();
+    if (ambientTrx) {
+      return ambientTrx;
+    }
+    return knex;
+  }
+
+  /**
+   * Get transaction handle for lifecycle hooks
+   * @returns {import('knex').Knex.Transaction|null}
+   */
+  function getHookTrx() {
+    const active = getActiveKnex();
+    return (active && (active.isTransaction || typeof active.commit === 'function')) ? active : null;
+  }
+
   /**
    * Get base query builder
    * @returns {import('knex').Knex.QueryBuilder}
    */
   function baseQuery() {
-    let qb = knex(model.table);
+    const activeKnex = getActiveKnex();
+    let qb = activeKnex(model.table);
     return applyScopes(qb, scopeContext, model);
   }
 
@@ -79,7 +105,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       }
 
       if (withs.length > 0) {
-        await loadRelations([record], ensureArray(withs), model, knex, scopeContext);
+        await loadRelations([record], ensureArray(withs), model, getActiveKnex(), scopeContext);
       }
 
       if (shouldEmit) {
@@ -105,7 +131,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
         kind,
         kind === 'pk' ? id : null
       );
-      return cacheLayer.wrapRead(model, knex, scopeContext, fingerprint, tags, loadFromDb, (r) => r != null);
+      return cacheLayer.wrapRead(model, getActiveKnex(), scopeContext, fingerprint, tags, loadFromDb, (r) => r != null);
     }
 
     return loadFromDb();
@@ -160,7 +186,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       }
 
       if (withs.length > 0) {
-        await loadRelations([record], ensureArray(withs), model, knex, scopeContext);
+        await loadRelations([record], ensureArray(withs), model, getActiveKnex(), scopeContext);
       }
 
       if (shouldEmit) {
@@ -172,7 +198,18 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
 
     if (cacheLayer && cacheLayer.strategyFor(model)) {
       const strat = cacheLayer.strategyFor(model);
-      const kind = isPkOnly ? 'pk' : 'collection';
+      if (isPkOnly) {
+        const pkVal = conditions[model.primaryKey];
+        const fingerprint = cacheLayer.findByIdFingerprint(
+          model,
+          scopeContext,
+          pkVal,
+          select || [],
+          withs
+        );
+        const tags = cacheLayer.buildReadTags(model, strat, 'pk', pkVal);
+        return cacheLayer.wrapRead(model, getActiveKnex(), scopeContext, fingerprint, tags, loadFromDb, (r) => r != null);
+      }
       const fingerprint = cacheLayer.findOneFingerprint(
         model,
         scopeContext,
@@ -180,20 +217,15 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
         select || [],
         withs
       );
-      const tags = cacheLayer.buildReadTags(
-        model,
-        strat,
-        kind,
-        kind === 'pk' ? conditions[model.primaryKey] : null
-      );
-      return cacheLayer.wrapRead(model, knex, scopeContext, fingerprint, tags, loadFromDb, (r) => r != null);
+      const tags = cacheLayer.buildReadTags(model, strat, 'collection', null);
+      return cacheLayer.wrapRead(model, getActiveKnex(), scopeContext, fingerprint, tags, loadFromDb, (r) => r != null);
     }
 
     return loadFromDb();
   }
 
   /**
-   * Find all records
+   * Find all records matching scope
    * @param {import('./types').FindOptions} [options={}] - Find options
    * @returns {Promise<Object[]>}
    */
@@ -229,7 +261,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       }
 
       if (withs.length > 0 && records.length > 0) {
-        await loadRelations(records, ensureArray(withs), model, knex, scopeContext);
+        await loadRelations(records, ensureArray(withs), model, getActiveKnex(), scopeContext);
       }
 
       if (shouldEmit) {
@@ -246,7 +278,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       const strat = cacheLayer.strategyFor(model);
       const fingerprint = cacheLayer.findAllFingerprint(model, scopeContext, select || []);
       const tags = cacheLayer.buildReadTags(model, strat, 'collection', null);
-      return cacheLayer.wrapRead(model, knex, scopeContext, fingerprint, tags, loadFromDb, () => true);
+      return cacheLayer.wrapRead(model, getActiveKnex(), scopeContext, fingerprint, tags, loadFromDb, () => true);
     }
 
     return loadFromDb();
@@ -258,7 +290,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {Promise<Object>}
    */
   async function create(data) {
-    const ctx = createEventContext(model.name, 'create', knex.isTransaction ? knex : null);
+    const ctx = createEventContext(model.name, 'create', getHookTrx());
     let workingData = { ...data };
 
     // Emit beforeValidation
@@ -294,7 +326,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     }
 
     // Insert and return the record
-    const [id] = await knex(model.table).insert(insertData).returning(model.primaryKey);
+    const [id] = await getActiveKnex()(model.table).insert(insertData).returning(model.primaryKey);
 
     // For databases that don't support returning (SQLite), id might be the row itself
     const insertedId = typeof id === 'object' ? id[model.primaryKey] : id;
@@ -334,7 +366,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {Promise<Object|null>}
    */
   async function update(id, data) {
-    const ctx = createEventContext(model.name, 'update', knex.isTransaction ? knex : null);
+    const ctx = createEventContext(model.name, 'update', getHookTrx());
     // Don't include primary key in working data for validation
     // to avoid type mismatch issues (URL params come as strings)
     let workingData = { ...data };
@@ -431,7 +463,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {Promise<boolean>}
    */
   async function del(id) {
-    const ctx = createEventContext(model.name, 'delete', knex.isTransaction ? knex : null);
+    const ctx = createEventContext(model.name, 'delete', getHookTrx());
     
     // Get the record before deletion for hooks
     const record = await findById(id);
@@ -476,7 +508,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    */
   async function forceDelete(id) {
     // Use raw query to bypass soft delete scope
-    const deleted = await knex(model.table)
+    const deleted = await getActiveKnex()(model.table)
       .where(model.primaryKey, id)
       .delete();
     if (cacheLayer && deleted > 0) {
@@ -495,10 +527,10 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       throw new Error(`Model "${model.name}" does not have soft delete enabled`);
     }
 
-    const ctx = createEventContext(model.name, 'restore', knex.isTransaction ? knex : null);
+    const ctx = createEventContext(model.name, 'restore', getHookTrx());
 
     // Get the trashed record for hooks (bypass soft delete scope)
-    const trashedRecord = await knex(model.table)
+    const trashedRecord = await getActiveKnex()(model.table)
       .where(model.primaryKey, id)
       .whereNotNull('deleted_at')
       .first();
@@ -514,7 +546,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     }
 
     // Update directly without scopes (to find trashed record)
-    const updated = await knex(model.table)
+    const updated = await getActiveKnex()(model.table)
       .where(model.primaryKey, id)
       .whereNotNull('deleted_at')
       .update({ deleted_at: null });
@@ -536,7 +568,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {import('./query-builder').QueryBuilder}
    */
   function query() {
-    return createQueryBuilder(model, knex, scopeContext, cacheLayer);
+    return createQueryBuilder(model, getActiveKnex(), scopeContext, cacheLayer);
   }
 
   /**
@@ -546,7 +578,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {Promise<Object[]>}
    */
   async function raw(sql, bindings = []) {
-    const result = await knex.raw(sql, bindings);
+    const result = await getActiveKnex().raw(sql, bindings);
     // Normalize result across database drivers
     return result.rows || result;
   }

package/core/orm/scopes.js

@@ -185,11 +185,12 @@ function applyUpdateModifiers(data, model) {
  * Create default scope context
  * @returns {import('./types').ScopeContext}
  */
-function createScopeContext() {
+function createScopeContext(overrides = {}) {
   return {
     tenantId: undefined,
     withTrashed: false,
     onlyTrashed: false,
+    ...overrides,
   };
 }
 

package/core/orm/transaction.js

@@ -1,12 +1,42 @@
 /**
  * Webspresso ORM - Transaction
- * Transaction wrapper with scoped repositories
+ * Transaction wrapper with scoped repositories and AsyncLocalStorage ambient transaction support
  * @module core/orm/transaction
  */
 
-const { createRepository } = require('./repository');
+const { AsyncLocalStorage } = require('async_hooks');
 const { createScopeContext } = require('./scopes');
 
+// AsyncLocalStorage instance holding the current active ambient transaction
+const ambientTransactionStorage = new AsyncLocalStorage();
+
+/**
+ * Execute a callback within an ambient transaction context
+ * @param {import('knex').Knex.Transaction} trx - Knex transaction
+ * @param {Function} callback - Function to execute
+ * @returns {Promise<*>} Result of callback
+ */
+function runWithAmbientTransaction(trx, callback) {
+  return ambientTransactionStorage.run({ trx }, callback);
+}
+
+/**
+ * Get the currently active ambient Knex transaction, or null if none
+ * @returns {import('knex').Knex.Transaction|null}
+ */
+function getAmbientTransaction() {
+  const store = ambientTransactionStorage.getStore();
+  return store && store.trx ? store.trx : null;
+}
+
+/**
+ * Check if there is an active ambient Knex transaction in current execution context
+ * @returns {boolean}
+ */
+function hasAmbientTransaction() {
+  return Boolean(getAmbientTransaction());
+}
+
 /**
  * Create a transaction context
  * @param {import('knex').Knex.Transaction} trx - Knex transaction
@@ -14,6 +44,7 @@ const { createScopeContext } = require('./scopes');
  * @returns {import('./types').TransactionContext}
  */
 function createTransactionContext(trx, scopeContext) {
+  const { createRepository } = require('./repository');
   const context = scopeContext || createScopeContext();
 
   return {
@@ -49,7 +80,7 @@ function createTransactionContext(trx, scopeContext) {
 }
 
 /**
- * Run a callback within a transaction
+ * Run a callback within a transaction and bind ambient transaction storage
  * @param {import('knex').Knex} knex - Knex instance
  * @param {function(import('./types').TransactionContext): Promise<*>} callback - Transaction callback
  * @param {import('./types').ScopeContext} [scopeContext] - Scope context
@@ -58,12 +89,15 @@ function createTransactionContext(trx, scopeContext) {
 async function runTransaction(knex, callback, scopeContext) {
   return knex.transaction(async (trx) => {
     const ctx = createTransactionContext(trx, scopeContext);
-    return callback(ctx);
+    return runWithAmbientTransaction(trx, () => callback(ctx));
   });
 }
 
 module.exports = {
+  ambientTransactionStorage,
+  runWithAmbientTransaction,
+  getAmbientTransaction,
+  hasAmbientTransaction,
   createTransactionContext,
   runTransaction,
 };
-