@decaf-ts/core 0.26.5 → 0.27.1

package/lib/esm/persistence/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/persistence/constants.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/persistence/constants.ts"],"names":[],"mappings":"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"}

package/lib/esm/persistence/transactions.js

@@ -4,8 +4,12 @@ import { TransactionalKeys } from "@decaf-ts/transactional-decorators";
 import { ModelService } from "./../services/ModelService.js";
 import { Repository } from "./../repository/Repository.js";
 import { Adapter } from "./Adapter.js";
-import { ContextLock } from "./ContextLock.js";
-export function getAdapterTransaction(obj, ...args) {
+/**
+ * @description Resolves the transaction lock for a `@transactional`-decorated call
+ * @summary Finds the underlying adapter for the decorated object (Adapter, Repository, or
+ * ModelService) and asks it for a fresh `ContextLock` via `Adapter.transactionLock()`
+ */
+export function resolveTransactionLock(obj, ...args) {
     let adapter;
     if (obj instanceof ModelService)
         adapter = obj.repo.adapter;
@@ -17,9 +21,6 @@ export function getAdapterTransaction(obj, ...args) {
         throw new InternalError(`Could not find adapter to extract transaction`);
     return adapter.transactionLock(...args);
 }
-export function getContextLock(obj, ...args) {
-    return new ContextLock(getAdapterTransaction(obj, ...args));
-}
 function innerTransactional(...data) {
     return function (target, propertyKey, descriptor) {
         if (!descriptor)
@@ -31,27 +32,43 @@ function innerTransactional(...data) {
         descriptor.value = new Proxy(descriptor.value, {
             async apply(obj, thisArg, argArray) {
                 const { log, ctx } = (await thisArg["logCtx"](argArray, obj.name, true)).for(obj);
-                const lock = ctx.getOrUndefined("transactionLock") || getContextLock(thisArg);
-                ctx.put("transactionLock", lock);
-                await lock.acquire();
+                // Reuse an in-flight transaction (nested @transactional call) instead of starting a new one
+                const existing = ctx.getOrUndefined("transactionLock");
+                const lock = existing || resolveTransactionLock(thisArg);
+                lock.depth++;
+                if (!existing) {
+                    // only cache the lock once begin() succeeds, so a rejected begin() (e.g.
+                    // maxConcurrentTransactions=0) leaves no stale lock/depth on the context
+                    await lock.begin(ctx);
+                    ctx.cache.put("transactionLock", lock);
+                }
                 let results;
                 try {
                     results = await obj.call(thisArg, ...argArray, ctx);
                 }
                 catch (e) {
+                    // An inner @transactional frame may have already rolled back and ended
+                    // the transaction (depth forced to 0); enclosing frames must not roll back again
+                    const alreadyEnded = lock.depth === 0;
+                    lock.depth = 0;
+                    if (!alreadyEnded) {
+                        try {
+                            await lock.rollback(e, ctx);
+                        }
+                        catch (rollbackError) {
+                            log.error(`Failed to rollback transaction`, rollbackError);
+                        }
+                    }
+                    throw e;
+                }
+                lock.depth--;
+                if (lock.depth === 0) {
                     try {
-                        await lock.rollback(e);
+                        await lock.commit(ctx);
                     }
                     catch (e) {
-                        log.error(`Failed to rollback transaction`, e);
+                        throw new InternalError(`Failed to commit transaction: ${e}`);
                     }
-                    throw e;
-                }
-                try {
-                    await lock.release();
-                }
-                catch (e) {
-                    throw new InternalError(`Failed to release transaction: ${e}`);
                 }
                 return results;
             },
@@ -59,9 +76,25 @@ function innerTransactional(...data) {
         return descriptor;
     };
 }
-Decoration.for(TransactionalKeys.TRANSACTIONAL)
-    .define({
-    decorator: innerTransactional,
-})
-    .apply();
+/**
+ * @description Method decorator that wraps a method in core's transaction-lock mechanism
+ * @summary `@decaf-ts/transactional-decorators` exports its own `transactional()` factory, and that
+ * factory re-registers its own (base) decorator under the same Decoration key every time it is called
+ * — so importing core does not make core's implementation "stick" if anything also calls the base
+ * package's factory. Consumers that want core's `ContextLock`/per-adapter transaction-lock behavior
+ * MUST import `transactional` from `@decaf-ts/core` (this function), not from
+ * `@decaf-ts/transactional-decorators`. Whichever factory is called last determines the active
+ * implementation for the shared key/flavour going forward.
+ * @param {...any[]} data - Optional metadata available to the transaction-lock implementation
+ * @function transactional
+ * @category Decorators
+ */
+export function transactional(...data) {
+    return Decoration.for(TransactionalKeys.TRANSACTIONAL)
+        .define({
+        decorator: innerTransactional,
+        args: data,
+    })
+        .apply();
+}
 //# sourceMappingURL=transactions.js.map

package/lib/esm/persistence/transactions.js.map

@@ -1 +1 @@
-{"version":3,"file":"transactions.js","sourceRoot":"","sources":["../../../src/persistence/transactions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"transactions.js","sourceRoot":"","sources":["../../../src/persistence/transactions.ts"],"names":[],"mappings":"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"}

package/lib/types/index.d.cts

@@ -24,21 +24,21 @@ export * from "./persistence/index.d.cts";
  * @const VERSION
  * @memberOf module:core
  */
-export declare const VERSION = "0.26.4";
+export declare const VERSION = "0.27.0";
 /**
  * @description Represents the current commit hash of the module build.
  * @summary Stores the current git commit hash for the package. The build replaces
  * the placeholder with the actual commit hash at publish time.
  * @const COMMIT
  */
-export declare const COMMIT = "698a38a";
+export declare const COMMIT = "ad6f037";
 /**
  * @description Represents the full version string of the module.
  * @summary Stores the semver version and commit hash for the package.
  * The build replaces the placeholder with the actual `<version>-<commit>` value at publish time.
  * @const FULL_VERSION
  */
-export declare const FULL_VERSION = "0.26.4-698a38a";
+export declare const FULL_VERSION = "0.27.0-ad6f037";
 /**
  * @description Stores the current package version
  * @summary A constant representing the version of the core package

package/lib/types/index.d.mts

@@ -24,21 +24,21 @@ export * from "./persistence/index.d.mts";
  * @const VERSION
  * @memberOf module:core
  */
-export declare const VERSION = "0.26.4";
+export declare const VERSION = "0.27.0";
 /**
  * @description Represents the current commit hash of the module build.
  * @summary Stores the current git commit hash for the package. The build replaces
  * the placeholder with the actual commit hash at publish time.
  * @const COMMIT
  */
-export declare const COMMIT = "698a38a";
+export declare const COMMIT = "ad6f037";
 /**
  * @description Represents the full version string of the module.
  * @summary Stores the semver version and commit hash for the package.
  * The build replaces the placeholder with the actual `<version>-<commit>` value at publish time.
  * @const FULL_VERSION
  */
-export declare const FULL_VERSION = "0.26.4-698a38a";
+export declare const FULL_VERSION = "0.27.0-ad6f037";
 /**
  * @description Stores the current package version
  * @summary A constant representing the version of the core package

package/lib/types/persistence/Adapter.d.cts

@@ -17,7 +17,7 @@ import { type Constructor } from "@decaf-ts/decoration";
 import { AbsContextual, ContextualArgs, ContextualizedArgs, MaybeContextualArg, MethodOrOperation } from "../utils/ContextualLoggedClass.d.cts";
 import { Paginator } from "../query/Paginator.d.cts";
 import { PreparedStatement } from "../query/types.d.cts";
-import { AdapterTransaction } from "./ContextLock.d.cts";
+import { ContextLock } from "./ContextLock.d.cts";
 export declare function resolveBulkSequenceResult<T>(result: T[] | PromiseSettledResult<T>[], continueOnError: boolean, log: Logger, operation: string): T[];
 export type AdapterSubClass<A> = A extends Adapter<any, any, any, any> ? A : never;
 /**
@@ -150,7 +150,15 @@ export declare abstract class Adapter<CONF, CONN, QUERY, CONTEXT extends Context
      * @return {Constructor<Repository<any, Adapter<CONF, CONN, QUERY, CONTEXT>>>} The repository constructor
      */
     repository<R extends Repository<any, Adapter<CONF, CONN, QUERY, CONTEXT>>>(): Constructor<R>;
-    transactionLock(...args: any[]): AdapterTransaction<this>;
+    /**
+     * @description Provides this adapter's transaction-lock implementation
+     * @summary Returns a fresh `ContextLock` instance used by `@transactional` to manage transaction
+     * boundaries. The base implementation is a no-op; adapters with native transaction support (e.g. a
+     * SQL adapter) should override this to return a `ContextLock` subclass that wraps the underlying
+     * driver's BEGIN/COMMIT/ROLLBACK. Nesting is handled by the `@transactional` proxy, not by this method
+     * or the returned lock.
+     */
+    transactionLock(...args: any[]): ContextLock<this>;
     protected shutdownProxies(...args: ContextualArgs<any>): Promise<void>;
     protected shutdownProxies(k: string, ...args: ContextualArgs<any>): Promise<void>;
     /**

package/lib/types/persistence/Adapter.d.mts

@@ -17,7 +17,7 @@ import { type Constructor } from "@decaf-ts/decoration";
 import { AbsContextual, ContextualArgs, ContextualizedArgs, MaybeContextualArg, MethodOrOperation } from "../utils/ContextualLoggedClass.d.mts";
 import { Paginator } from "../query/Paginator.d.mts";
 import { PreparedStatement } from "../query/types.d.mts";
-import { AdapterTransaction } from "./ContextLock.d.mts";
+import { ContextLock } from "./ContextLock.d.mts";
 export declare function resolveBulkSequenceResult<T>(result: T[] | PromiseSettledResult<T>[], continueOnError: boolean, log: Logger, operation: string): T[];
 export type AdapterSubClass<A> = A extends Adapter<any, any, any, any> ? A : never;
 /**
@@ -150,7 +150,15 @@ export declare abstract class Adapter<CONF, CONN, QUERY, CONTEXT extends Context
      * @return {Constructor<Repository<any, Adapter<CONF, CONN, QUERY, CONTEXT>>>} The repository constructor
      */
     repository<R extends Repository<any, Adapter<CONF, CONN, QUERY, CONTEXT>>>(): Constructor<R>;
-    transactionLock(...args: any[]): AdapterTransaction<this>;
+    /**
+     * @description Provides this adapter's transaction-lock implementation
+     * @summary Returns a fresh `ContextLock` instance used by `@transactional` to manage transaction
+     * boundaries. The base implementation is a no-op; adapters with native transaction support (e.g. a
+     * SQL adapter) should override this to return a `ContextLock` subclass that wraps the underlying
+     * driver's BEGIN/COMMIT/ROLLBACK. Nesting is handled by the `@transactional` proxy, not by this method
+     * or the returned lock.
+     */
+    transactionLock(...args: any[]): ContextLock<this>;
     protected shutdownProxies(...args: ContextualArgs<any>): Promise<void>;
     protected shutdownProxies(k: string, ...args: ContextualArgs<any>): Promise<void>;
     /**

package/lib/types/persistence/ContextLock.d.cts

@@ -1,18 +1,76 @@
-import { Lock } from "@decaf-ts/transactional-decorators";
 import { type Adapter } from "./Adapter.d.cts";
-export declare class AdapterTransaction<A extends Adapter<any, any, any, any>> {
+import { type Context } from "./Context.d.cts";
+import { Lock } from "@decaf-ts/transactional-decorators";
+/**
+ * @description Counting semaphore used by the default `ContextLock` to gate concurrent transactions
+ * @summary Simple FIFO semaphore: `acquire()` resolves immediately while permits remain, otherwise the
+ * caller is queued and resolved (without touching the permit count) the moment `release()` hands the
+ * permit directly to the next waiter. `SimpleConcurrencyLock.for(adapter, limit)` is the single,
+ * self-contained way to get the one gate shared by every transaction on that adapter - no extra state
+ * or methods live on `Adapter` itself for this.
+ * @class SimpleConcurrencyLock
+ */
+export declare class SimpleConcurrencyLock extends Lock {
+    private static readonly registry;
+    /**
+     * @description Returns the one `SimpleConcurrencyLock` for this adapter, creating it on first use
+     * @summary `limit` only matters the first time it's called for a given adapter - the gate's capacity
+     * is fixed for the adapter's lifetime, the same way the adapter's own client/connection is.
+     */
+    static for(adapter: Adapter<any, any, any, any>, limit: number): SimpleConcurrencyLock;
+    private permits;
+    private readonly waiters;
+    private constructor();
+    acquire(ctx?: Context<any>): Promise<void>;
+    release(ctx?: Context<any>): void;
+}
+/**
+ * @description Per-adapter transaction lock
+ * @summary Default transaction boundary implementation stored on the Context by `@transactional`.
+ * Gated by the `maxConcurrentTransactions` flag (see `AdapterFlags`): `-1` (default) means no limit and
+ * `begin`/`commit`/`rollback` behave as a no-op; `0` disables transactions outright (every call throws);
+ * any positive number gates concurrent transactions through `SimpleConcurrencyLock.for(adapter, limit)`,
+ * the one counting semaphore shared by every transaction on that adapter, queuing callers until a slot
+ * frees up.
+ * Adapters with native transaction support (e.g. a SQL adapter wrapping BEGIN/COMMIT/ROLLBACK) override
+ * `Adapter.transactionLock()` to return a subclass with real `begin`/`commit`/`rollback` behavior - if that
+ * subclass does not call `super.begin()`/`super.commit()`/`super.rollback()`, `maxConcurrentTransactions`
+ * has no effect for it, since concurrency is then governed by the underlying database instead.
+ * `transactionLock()` always returns a *fresh* `ContextLock` per top-level transaction - it's the
+ * per-transaction handle (nesting `depth`, and for native adapters the actual exclusive connection/cursor),
+ * so it cannot be a singleton itself; only the concurrency gate it delegates to is shared.
+ * Nesting (reusing the same instance across nested `@transactional` calls, and deciding when to actually
+ * call `begin`/`commit`/`rollback`) is owned by the `@transactional` proxy via `depth`, not by this class.
+ * @class ContextLock
+ */
+export declare class ContextLock<A extends Adapter<any, any, any, any> = Adapter<any, any, any, any>> {
     protected adapter: A;
+    /**
+     * @description Nesting depth, owned and mutated by the `@transactional` proxy
+     */
+    depth: number;
+    private semaphore?;
     constructor(adapter: A, ...args: any[]);
-    begin(...args: any[]): Promise<void>;
-    commit(...args: any[]): Promise<void>;
-    rollback(...args: any[]): Promise<void>;
-}
-export declare class ContextLock extends Lock {
-    protected adapterTransaction: AdapterTransaction<any>;
-    private acquireCount;
-    protected readonly lock: Lock;
-    constructor(adapterTransaction: AdapterTransaction<any>);
-    acquire(...args: any[]): Promise<void>;
-    release(...args: any[]): Promise<void>;
-    rollback(e: Error, ...args: any[]): Promise<void>;
+    /**
+     * @description Called once, by the outermost `@transactional` call
+     * @summary `context` already exists by the time this is called (the `@transactional` proxy always
+     * builds it before calling `begin`), so this routes it through `Adapter.logCtx()` with `allowCreate`
+     * left at its default `false` - there is nothing to create here, only the existing context (and its
+     * logger) to reuse. Passing `allowCreate: true` would be wrong: it skips the "reuse the context I was
+     * given" branch entirely and tries to build a new one through `Adapter.context()`, whose third
+     * positional parameter is reserved for a model constructor - the context would be misread as "model".
+     * @param {Context<any>} context - The context the transaction is starting under
+     */
+    begin(context: Context<any>): Promise<void>;
+    /**
+     * @description Called once, when the outermost `@transactional` call exits successfully
+     * @param {Context<any>} context - The context the transaction ran under
+     */
+    commit(context: Context<any>): Promise<void>;
+    /**
+     * @description Called once, by whichever call hits the error first. Ends the transaction outright
+     * @param {Error} err - The error that triggered the rollback
+     * @param {Context<any>} context - The context the transaction ran under
+     */
+    rollback(err: Error, context: Context<any>): Promise<void>;
 }

package/lib/types/persistence/ContextLock.d.mts

@@ -1,18 +1,76 @@
-import { Lock } from "@decaf-ts/transactional-decorators";
 import { type Adapter } from "./Adapter.d.mts";
-export declare class AdapterTransaction<A extends Adapter<any, any, any, any>> {
+import { type Context } from "./Context.d.mts";
+import { Lock } from "@decaf-ts/transactional-decorators";
+/**
+ * @description Counting semaphore used by the default `ContextLock` to gate concurrent transactions
+ * @summary Simple FIFO semaphore: `acquire()` resolves immediately while permits remain, otherwise the
+ * caller is queued and resolved (without touching the permit count) the moment `release()` hands the
+ * permit directly to the next waiter. `SimpleConcurrencyLock.for(adapter, limit)` is the single,
+ * self-contained way to get the one gate shared by every transaction on that adapter - no extra state
+ * or methods live on `Adapter` itself for this.
+ * @class SimpleConcurrencyLock
+ */
+export declare class SimpleConcurrencyLock extends Lock {
+    private static readonly registry;
+    /**
+     * @description Returns the one `SimpleConcurrencyLock` for this adapter, creating it on first use
+     * @summary `limit` only matters the first time it's called for a given adapter - the gate's capacity
+     * is fixed for the adapter's lifetime, the same way the adapter's own client/connection is.
+     */
+    static for(adapter: Adapter<any, any, any, any>, limit: number): SimpleConcurrencyLock;
+    private permits;
+    private readonly waiters;
+    private constructor();
+    acquire(ctx?: Context<any>): Promise<void>;
+    release(ctx?: Context<any>): void;
+}
+/**
+ * @description Per-adapter transaction lock
+ * @summary Default transaction boundary implementation stored on the Context by `@transactional`.
+ * Gated by the `maxConcurrentTransactions` flag (see `AdapterFlags`): `-1` (default) means no limit and
+ * `begin`/`commit`/`rollback` behave as a no-op; `0` disables transactions outright (every call throws);
+ * any positive number gates concurrent transactions through `SimpleConcurrencyLock.for(adapter, limit)`,
+ * the one counting semaphore shared by every transaction on that adapter, queuing callers until a slot
+ * frees up.
+ * Adapters with native transaction support (e.g. a SQL adapter wrapping BEGIN/COMMIT/ROLLBACK) override
+ * `Adapter.transactionLock()` to return a subclass with real `begin`/`commit`/`rollback` behavior - if that
+ * subclass does not call `super.begin()`/`super.commit()`/`super.rollback()`, `maxConcurrentTransactions`
+ * has no effect for it, since concurrency is then governed by the underlying database instead.
+ * `transactionLock()` always returns a *fresh* `ContextLock` per top-level transaction - it's the
+ * per-transaction handle (nesting `depth`, and for native adapters the actual exclusive connection/cursor),
+ * so it cannot be a singleton itself; only the concurrency gate it delegates to is shared.
+ * Nesting (reusing the same instance across nested `@transactional` calls, and deciding when to actually
+ * call `begin`/`commit`/`rollback`) is owned by the `@transactional` proxy via `depth`, not by this class.
+ * @class ContextLock
+ */
+export declare class ContextLock<A extends Adapter<any, any, any, any> = Adapter<any, any, any, any>> {
     protected adapter: A;
+    /**
+     * @description Nesting depth, owned and mutated by the `@transactional` proxy
+     */
+    depth: number;
+    private semaphore?;
     constructor(adapter: A, ...args: any[]);
-    begin(...args: any[]): Promise<void>;
-    commit(...args: any[]): Promise<void>;
-    rollback(...args: any[]): Promise<void>;
-}
-export declare class ContextLock extends Lock {
-    protected adapterTransaction: AdapterTransaction<any>;
-    private acquireCount;
-    protected readonly lock: Lock;
-    constructor(adapterTransaction: AdapterTransaction<any>);
-    acquire(...args: any[]): Promise<void>;
-    release(...args: any[]): Promise<void>;
-    rollback(e: Error, ...args: any[]): Promise<void>;
+    /**
+     * @description Called once, by the outermost `@transactional` call
+     * @summary `context` already exists by the time this is called (the `@transactional` proxy always
+     * builds it before calling `begin`), so this routes it through `Adapter.logCtx()` with `allowCreate`
+     * left at its default `false` - there is nothing to create here, only the existing context (and its
+     * logger) to reuse. Passing `allowCreate: true` would be wrong: it skips the "reuse the context I was
+     * given" branch entirely and tries to build a new one through `Adapter.context()`, whose third
+     * positional parameter is reserved for a model constructor - the context would be misread as "model".
+     * @param {Context<any>} context - The context the transaction is starting under
+     */
+    begin(context: Context<any>): Promise<void>;
+    /**
+     * @description Called once, when the outermost `@transactional` call exits successfully
+     * @param {Context<any>} context - The context the transaction ran under
+     */
+    commit(context: Context<any>): Promise<void>;
+    /**
+     * @description Called once, by whichever call hits the error first. Ends the transaction outright
+     * @param {Error} err - The error that triggered the rollback
+     * @param {Context<any>} context - The context the transaction ran under
+     */
+    rollback(err: Error, context: Context<any>): Promise<void>;
 }

package/lib/types/persistence/transactions.d.cts

@@ -1,4 +1,21 @@
-import { Adapter } from "../persistence/Adapter.d.cts";
 import { ContextLock } from "../persistence/ContextLock.d.cts";
-export declare function getAdapterTransaction(obj: any, ...args: any[]): import(".").AdapterTransaction<Adapter<any, any, any, any>>;
-export declare function getContextLock(obj: any, ...args: any[]): ContextLock;
+/**
+ * @description Resolves the transaction lock for a `@transactional`-decorated call
+ * @summary Finds the underlying adapter for the decorated object (Adapter, Repository, or
+ * ModelService) and asks it for a fresh `ContextLock` via `Adapter.transactionLock()`
+ */
+export declare function resolveTransactionLock(obj: any, ...args: any[]): ContextLock;
+/**
+ * @description Method decorator that wraps a method in core's transaction-lock mechanism
+ * @summary `@decaf-ts/transactional-decorators` exports its own `transactional()` factory, and that
+ * factory re-registers its own (base) decorator under the same Decoration key every time it is called
+ * — so importing core does not make core's implementation "stick" if anything also calls the base
+ * package's factory. Consumers that want core's `ContextLock`/per-adapter transaction-lock behavior
+ * MUST import `transactional` from `@decaf-ts/core` (this function), not from
+ * `@decaf-ts/transactional-decorators`. Whichever factory is called last determines the active
+ * implementation for the shared key/flavour going forward.
+ * @param {...any[]} data - Optional metadata available to the transaction-lock implementation
+ * @function transactional
+ * @category Decorators
+ */
+export declare function transactional(...data: any[]): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/persistence/transactions.d.mts

@@ -1,4 +1,21 @@
-import { Adapter } from "../persistence/Adapter.d.mts";
 import { ContextLock } from "../persistence/ContextLock.d.mts";
-export declare function getAdapterTransaction(obj: any, ...args: any[]): import(".").AdapterTransaction<Adapter<any, any, any, any>>;
-export declare function getContextLock(obj: any, ...args: any[]): ContextLock;
+/**
+ * @description Resolves the transaction lock for a `@transactional`-decorated call
+ * @summary Finds the underlying adapter for the decorated object (Adapter, Repository, or
+ * ModelService) and asks it for a fresh `ContextLock` via `Adapter.transactionLock()`
+ */
+export declare function resolveTransactionLock(obj: any, ...args: any[]): ContextLock;
+/**
+ * @description Method decorator that wraps a method in core's transaction-lock mechanism
+ * @summary `@decaf-ts/transactional-decorators` exports its own `transactional()` factory, and that
+ * factory re-registers its own (base) decorator under the same Decoration key every time it is called
+ * — so importing core does not make core's implementation "stick" if anything also calls the base
+ * package's factory. Consumers that want core's `ContextLock`/per-adapter transaction-lock behavior
+ * MUST import `transactional` from `@decaf-ts/core` (this function), not from
+ * `@decaf-ts/transactional-decorators`. Whichever factory is called last determines the active
+ * implementation for the shared key/flavour going forward.
+ * @param {...any[]} data - Optional metadata available to the transaction-lock implementation
+ * @function transactional
+ * @category Decorators
+ */
+export declare function transactional(...data: any[]): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/persistence/types.d.cts

@@ -78,6 +78,15 @@ export type AdapterFlags<LOG extends Logger = Logger> = RepositoryFlags<LOG> & C
     paginateByBookmark: boolean;
     dryRun: boolean;
     lock?: ContextLock;
+    /**
+     * @description Maximum number of concurrent transactions the default `ContextLock` allows for this adapter
+     * @summary `-1` (default) means no limit - the default lock behaves as a no-op. `0` disables transactions
+     * entirely (every `@transactional()` call throws). Any positive number gates concurrent transactions through
+     * a counting semaphore, queuing callers until a slot frees up. Adapters with native transaction support
+     * (e.g. a SQL adapter) that fully override `ContextLock.begin()`/`commit()`/`rollback()` are not affected by
+     * this flag - concurrency there is governed by the underlying database instead.
+     */
+    maxConcurrentTransactions: number;
 };
 export type RawResult<R, D extends boolean> = D extends true ? R : {
     data: R;

package/lib/types/persistence/types.d.mts

@@ -78,6 +78,15 @@ export type AdapterFlags<LOG extends Logger = Logger> = RepositoryFlags<LOG> & C
     paginateByBookmark: boolean;
     dryRun: boolean;
     lock?: ContextLock;
+    /**
+     * @description Maximum number of concurrent transactions the default `ContextLock` allows for this adapter
+     * @summary `-1` (default) means no limit - the default lock behaves as a no-op. `0` disables transactions
+     * entirely (every `@transactional()` call throws). Any positive number gates concurrent transactions through
+     * a counting semaphore, queuing callers until a slot frees up. Adapters with native transaction support
+     * (e.g. a SQL adapter) that fully override `ContextLock.begin()`/`commit()`/`rollback()` are not affected by
+     * this flag - concurrency there is governed by the underlying database instead.
+     */
+    maxConcurrentTransactions: number;
 };
 export type RawResult<R, D extends boolean> = D extends true ? R : {
     data: R;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/core",
-  "version": "0.26.5",
+  "version": "0.27.1",
   "description": "Core persistence module for the decaf framework",
   "type": "module",
   "exports": {