@rapidrest/service-core 1.0.0-rc.7 → 1.0.0

package/dist/types/Server.d.ts

@@ -1,12 +1,29 @@
 import * as prom from "prom-client";
 import "reflect-metadata";
 import { ConnectionManager } from "./database/ConnectionManager.js";
+import { ClassLoader } from "@rapidrest/core";
 import { ObjectFactory } from "./ObjectFactory.js";
 import { BackgroundServiceManager } from "./BackgroundServiceManager.js";
 import { RouteUtils } from "./routes/RouteUtils.js";
 import { OpenApiSpec } from "./OpenApiSpec.js";
 import { EventListenerManager } from "./EventListenerManager.js";
-import { HttpRouter } from "./http/Router.js";
+import type { IHttpRouter } from "./http/types.js";
+import { SessionManager } from "./http/session/SessionManager.js";
+/**
+ * The configuration options to use when constructing a new Server instance.
+ */
+export interface ServerOptions {
+    /** The nconf-compatible configuration object to initialize the server with. */
+    config: any;
+    /** The base file system path that models and routes will be searched from. Default is `.` */
+    basePath?: string;
+    /** The logging utility to use for outputing to console/file. Default is `Logger()` from `@rapidrest/core`. */
+    logger?: any;
+    /** The ClassLoader used to scan the source for all exported classes. */
+    classLoader?: ClassLoader;
+    /** The object factory to use for automatic dependency injection (IOC). */
+    objectFactory?: ObjectFactory;
+}
 /**
  * Provides an HTTP server utilizing uWebSockets.js. The server automatically registers all routes, and
  * establishes database connections for all configured data stores. Additionally provides automatic authentication
@@ -116,14 +133,16 @@ import { HttpRouter } from "./http/Router.js";
 export declare class Server {
     /** The OpenAPI specification object to use to construct the server with. */
     protected apiSpec?: OpenApiSpec;
-    /** The underlying HTTP router (uWS-backed) that provides HTTP processing services. */
-    protected app: HttpRouter;
+    /** The underlying HTTP router (uWS-backed on Node, Bun.serve()-backed under the Bun runtime) that provides HTTP processing services. */
+    protected app: IHttpRouter;
     /** The base file system path that will be searched for models and routes. */
     protected readonly basePath: string;
     /** The global object containing configuration information to use. */
     protected readonly config?: any;
     /** The manager for handling database connections. */
     protected connectionManager?: ConnectionManager;
+    /** The ClassLoader used to scan the source for all exported classes. */
+    protected classLoader: ClassLoader;
     /** The manager for handling events. */
     protected eventListenerManager?: EventListenerManager;
     /** The logging utility to use when outputing to console/file. */
@@ -134,6 +153,8 @@ export declare class Server {
     readonly port: number;
     protected routeUtils?: RouteUtils;
     protected serviceManager?: BackgroundServiceManager;
+    /** Manages cross-request session support. Only set when a `session` config block is present. */
+    protected sessionManager?: SessionManager;
     protected metricRequestPath: prom.Counter<string>;
     protected metricRequestStatus: prom.Counter<string>;
     protected metricRequestTime: prom.Histogram<string>;
@@ -141,18 +162,15 @@ export declare class Server {
     protected metricFailedRequests: prom.Counter<string>;
     protected metricTotalRequests: prom.Counter<string>;
     /**
-     * Creates a new instance of Server with the specified defaults.
+     * Creates a new instance of Server with the specified default options.
      *
-     * @param {any} config The nconf-compatible configuration object to initialize the server with.
-     * @param {string} basePath The base file system path that models and routes will be searched from.
-     * @param {Logger} logger The logging utility to use for outputing to console/file.
-     * @param objectFactory The object factory to use for automatic dependency injection (IOC).
+     * @param options The configuration options to apply for this server.
      */
-    constructor(config: any, basePath?: string, logger?: any, objectFactory?: ObjectFactory);
+    constructor(options: ServerOptions);
     /**
      * Returns the HTTP router instance.
      */
-    getApplication(): HttpRouter;
+    getApplication(): IHttpRouter;
     /**
      * Returns `true` if the server is running, otherwise `false`.
      */

package/dist/types/auth/AuthMiddleware.d.ts

@@ -1,14 +1,14 @@
-import { HttpRequest, HttpResponse, RequestHandler } from "../http/types.js";
-import { AuthResult, AuthStrategy } from "./AuthStrategy.js";
+import type { HttpRequest, HttpResponse, RequestHandler } from "../http/types.js";
+import type { AuthResult, AuthStrategy } from "./AuthStrategy.js";
 /**
  * A set of common utilities for performing authentication using one or more strategies.
  *
  * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
  */
 export declare class AuthMiddleware {
+    private _objectFactory?;
     private authConfig;
     private authSocketTimeout;
-    private objectFactory?;
     /** The authentication strategies that have been registered. */
     readonly strategies: Map<string, AuthStrategy>;
     private init;

package/dist/types/auth/AuthStrategy.d.ts

@@ -1,15 +1,20 @@
-import { JWTUser } from "@rapidrest/core";
-import { HttpRequest, HttpResponse } from "../http/types.js";
+import type { JWTUser } from "@rapidrest/core";
+import type { HttpRequest, HttpResponse } from "../http/types.js";
 /**
  * Result returned by `AuthStrategy.authenticate()`.
  */
 export interface AuthResult {
     /** The raw auth data that was verified. */
-    data?: string;
+    data?: any;
     /** The name of the auth strategy that produced this result. */
     method: string;
     /** The fully decoded payload from the auth data. */
     payload?: any;
+    /**
+     * Client-supplied app-correlation data extracted from the `state` round-trip, if any (see
+     * OAuthStrategy's combined state/CSRF design). Available to route handlers via `@AuthResult`.
+     */
+    state?: string;
     /** The authenticated user profile, or `undefined` if authentication failed. */
     user?: JWTUser;
 }
@@ -26,9 +31,8 @@ export interface AuthStrategy {
      *
      * @param req The request containing data to attempt authentication with.
      * @param res The response to use when writing back directly to the client.
-     * @param required Set to `true` to if authentication is required to pass, otherwise set to `false`.
      */
-    authenticate(req: HttpRequest, res?: HttpResponse, required?: boolean): Promise<AuthResult | undefined>;
+    authenticate(req: HttpRequest, res?: HttpResponse): Promise<AuthResult | undefined>;
     /**
      * Attempts to perform authentication with the given request data. If authentication was successful, returns an
      * `AuthResult` containing the authentication details. If authentication fails and `required` is set to `true`
@@ -38,7 +42,6 @@ export interface AuthStrategy {
      *
      * @param req The request containing data to attempt authentication with.
      * @param res The response to use when writing back directly to the client.
-     * @param required Set to `true` to if authentication is required to pass, otherwise set to `false`.
      */
-    authenticateSync(req: HttpRequest, res?: HttpResponse, required?: boolean): AuthResult | undefined;
+    authenticateSync(req: HttpRequest, res?: HttpResponse): AuthResult | undefined;
 }

package/dist/types/auth/JWTStrategy.d.ts

@@ -1,6 +1,6 @@
-import { JWTUtilsConfig } from "@rapidrest/core";
+import { type JWTUtilsConfig } from "@rapidrest/core";
 import type { HttpRequest, HttpResponse } from "../http/types.js";
-import { AuthResult } from "./AuthStrategy.js";
+import type { AuthResult } from "./AuthStrategy.js";
 /**
  * Describes the configuration options that can be used to initialize JWTStrategy.
  *
@@ -50,16 +50,18 @@ export interface JWTAuthResult extends AuthResult {
  */
 export declare class JWTStrategy {
     private config;
+    private logger;
     readonly name: string;
     private options;
     private readonly _headerSchemeRegex;
     constructor(options?: JWTStrategyOptions);
+    private init;
     /**
      * Scans the provided request object for an authentication token this strategy can process.
      * @param req The request to scan for an auth token.
      * @returns The auth token if found, otherwise `undefined`.
      */
     private getAuthToken;
-    authenticate(req: HttpRequest, res: HttpResponse, required?: boolean): Promise<JWTAuthResult | undefined>;
-    authenticateSync(req: HttpRequest, res: HttpResponse, required?: boolean): JWTAuthResult | undefined;
+    authenticate(req: HttpRequest, res: HttpResponse): Promise<JWTAuthResult | undefined>;
+    authenticateSync(req: HttpRequest, res: HttpResponse): JWTAuthResult | undefined;
 }

package/dist/types/auth/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./AuthMiddleware.js";
 export * from "./AuthStrategy.js";
-export * from "./BasicStrategy.js";
 export * from "./JWTStrategy.js";

package/dist/types/database/ConnectionKinds.d.ts

@@ -5,3 +5,10 @@
  * @param conn The connection object to inspect.
  */
 export declare function isSqlDataSource(conn: any): boolean;
+/**
+ * Dynamically imports the `redis` package, throwing a helpful error if it isn't installed. `redis` is a peer
+ * dependency (like `mongodb` and `typeorm`) rather than a hard dependency of this package, so it must only be
+ * loaded when a consumer actually configures a redis-backed feature — never imported at the top of a module
+ * that's always loaded, or every consumer would be forced to install it regardless of whether they use it.
+ */
+export declare function importRedis(): Promise<typeof import("redis")>;

package/dist/types/database/ConnectionManager.d.ts

@@ -1,26 +1,41 @@
-import { Redis } from "ioredis";
 import type { DataSource } from "typeorm";
 import { MongoConnection } from "./MongoConnection.js";
+import type { RedisClientType } from "redis";
 /**
  * Provides database connection management.
  *
  * @author Jean-Philippe Steinmetz
  */
 export declare class ConnectionManager {
-    connections: Map<string, DataSource | MongoConnection | Redis>;
+    connections: Map<string, DataSource | MongoConnection | RedisClientType>;
     private logger;
     /**
      * Builds a compatible connection URI for the database by the provided configuration.
      */
     private buildConnectionUri;
+    /**
+     * Redacts the userinfo (credentials) portion of a connection URI for safe logging, regardless of
+     * whether the URI came from a `url` config field or was built from separate username/password fields.
+     */
+    private redactUri;
     /**
      * Dynamically imports the given optional peer dependency, throwing a helpful error if it is not installed.
      *
      * @param pkg The name of the package to import.
-     * @param datastoreName The name of the datastore requiring the package.
-     * @param datastoreType The type of the datastore requiring the package.
+     * @param datastoreName The name of the datasource requiring the package.
+     * @param datastoreType The type of the datasource requiring the package.
      */
     private importOptionalDependency;
+    /**
+     * Determines whether the given MongoDB deployment supports multi-document transactions (i.e. is configured
+     * as a replica set or a sharded cluster) by inspecting the `hello` handshake response. A standalone
+     * `mongod` responds with neither `setName` (replica set membership) nor `msg: "isdbgrid"` (mongos), and
+     * doesn't support transactions at all.
+     *
+     * @param db The database to check.
+     * @param name The name of the datastore, used only for the log message if transactions aren't supported.
+     */
+    private detectMongoTransactionSupport;
     /**
      * Attempts to initiate all database connections as defined in the config.
      *
@@ -28,6 +43,16 @@ export declare class ConnectionManager {
      * @param models A map of model names and associated class definitions to establish database connections for.
      */
     connect(datastores: any, models: Map<string, any>): Promise<void>;
+    /**
+     * Establishes (or reconnects) a single configured datasource connection and stores it in `this.connections`.
+     *
+     * @param name The configured name of the datasource.
+     * @param datasource The datasource's configuration.
+     * @param models A map of model names and associated class definitions to establish database connections for.
+     * @param processedModels Tracks which datasource each model class has already been claimed as an entity for,
+     * shared across every concurrent call from `connect()` so a model claimed by two datastores is still caught.
+     */
+    private connectDatastore;
     /**
      * Attempts to disconnect all active database connections.
      */

package/dist/types/database/MongoConnection.d.ts

@@ -1,8 +1,8 @@
-import type { Admin, Db, MongoClient } from "mongodb";
+import type { Admin, ClientSession, ClientSessionOptions, Db, MongoClient } from "mongodb";
 import { MongoRepository } from "./MongoRepository.js";
 /**
  * Represents a single named connection to a MongoDB database using the native `mongodb` driver, including the
- * registry of all model classes assigned to the connection's datastore.
+ * registry of all model classes assigned to the connection's datasource.
  *
  * Note that this class only references the `mongodb` package via type-only imports and is therefore safe to load
  * when the optional `mongodb` peer dependency is not installed.
@@ -14,12 +14,17 @@ export declare class MongoConnection {
     readonly client: MongoClient;
     /** The database that this connection is bound to. */
     readonly db: Db;
-    /** The name of the datastore that this connection was created for. */
+    /** The name of the datasource that this connection was created for. */
     readonly name: string;
+    /**
+     * Indicates whether this connection's MongoDB deployment supports multi-document transactions.
+     * Defaults to `false`.
+     */
+    readonly supportsTransactions: boolean;
     private connected;
     private entities;
     private repos;
-    constructor(name: string, client: MongoClient, db: Db, entities?: Iterable<any>);
+    constructor(name: string, client: MongoClient, db: Db, entities?: Iterable<any>, supportsTransactions?: boolean);
     /** Indicates whether or not the connection is currently active. */
     get isConnected(): boolean;
     /** Returns the admin interface of the underlying database. */
@@ -51,4 +56,11 @@ export declare class MongoConnection {
      * @param classOrName The model class, or the name of a registered model class, to retrieve a repository for.
      */
     getMongoRepository<T extends object = any>(classOrName: any | string): MongoRepository<T>;
+    /**
+     * Creates a new client session for performing transactions using the provided options.
+     *
+     * @param options The options to start the session with.
+     * @returns The newly started session.
+     */
+    startSession(options?: ClientSessionOptions): ClientSession;
 }

package/dist/types/database/MongoRepository.d.ts

@@ -1,4 +1,4 @@
-import type { AggregationCursor, Collection, CountDocumentsOptions, Db, DeleteOptions, DeleteResult, Document, Filter, FindCursor, FindOptions, UpdateOptions, UpdateResult } from "mongodb";
+import type { Abortable, AggregateOptions, AggregationCursor, Collection, CountDocumentsOptions, Db, DeleteOptions, DeleteResult, DistinctOptions, Document, Filter, FindCursor, FindOneAndDeleteOptions, FindOptions, InsertOneOptions, ReplaceOptions, UpdateOptions, UpdateResult } from "mongodb";
 /**
  * Provides a lightweight repository for performing common operations against a single MongoDB collection using the
  * native `mongodb` driver. Instances of this class are obtained via `MongoConnection.getRepository`.
@@ -23,19 +23,19 @@ export declare class MongoRepository<T extends Document = any> {
      *
      * @param pipeline The aggregation pipeline stages to execute.
      */
-    aggregate(pipeline: Document[]): AggregationCursor<any>;
+    aggregate(pipeline: Document[], options?: AggregateOptions & Abortable): AggregationCursor<any>;
     /**
      * Drops the entire collection from the database, removing all documents and indexes. Does nothing if the
      * collection does not exist.
      */
-    clear(): Promise<void>;
+    clear(options?: DeleteOptions & Abortable): Promise<void>;
     /**
      * Returns the number of documents matching the given filter.
      *
      * @param filter - The filter for the count
      * @param options - Optional settings for the command
      */
-    count(filter?: Filter<T>, options?: CountDocumentsOptions): Promise<number>;
+    count(filter?: Filter<T>, options?: CountDocumentsOptions & Abortable): Promise<number>;
     /**
      * Deletes all documents matching the given filter.
      *
@@ -50,35 +50,56 @@ export declare class MongoRepository<T extends Document = any> {
      * @param options - Optional settings for the command
      */
     deleteOne(filter?: Filter<T>, options?: DeleteOptions): Promise<DeleteResult>;
+    /**
+     * Atomically finds and deletes the first document matching the given filter, returning the document that
+     * was deleted (or `null` if none matched). This is a single round trip rather than a separate `findOne()` +
+     * `deleteOne()`, so a caller that needs to know exactly what it removed (e.g. to snapshot it for a
+     * possible restore) isn't racing its own read against a concurrent write to the same document.
+     *
+     * @param filter The query filter to match documents against.
+     * @param options - Optional settings for the command
+     */
+    findOneAndDelete(filter: Filter<T>, options?: FindOneAndDeleteOptions): Promise<T | null>;
     /**
      * Returns the list of distinct values of the given field for all documents matching the given filter.
      *
      * @param field The name of the document field to return distinct values of.
      * @param filter The query filter to match documents against.
      */
-    distinct(field: string, filter?: Filter<T>): Promise<any[]>;
+    distinct(field: string, filter?: Filter<T>, options?: DistinctOptions): Promise<any[]>;
     /**
      * Returns all documents matching the given filter.
      *
      * @param filter The query filter to match documents against.
      * @param options - Optional settings for the command
      */
-    find(filter?: Filter<T>, options?: FindOptions): FindCursor<T>;
+    find(filter?: Filter<T>, options?: FindOptions & Abortable): FindCursor<T>;
     /**
      * Returns the first document matching the given filter.
      *
      * @param filter The query filter to match documents against.
      */
-    findOne(filter: any): Promise<T | null>;
+    findOne(filter: any, options?: FindOptions & Abortable): Promise<T | null>;
     /**
-     * Saves the given document to the collection. If the document has an existing `_id` the stored document is
-     * replaced (inserting if missing), otherwise the document is inserted and its newly assigned `_id` is set on
-     * the returned object.
+     * Saves the given document to the collection. By default, if the document has an existing `_id` the stored
+     * document is replaced (inserting if missing), otherwise the document is inserted and its newly assigned
+     * `_id` is set on the returned object. This is the behavior a trackChanges-style caller relies on to keep
+     * multiple documents per `uid` (one per version): a document built for a fresh version deliberately carries
+     * no `_id` yet, and must always become a genuinely new row, never merged into an existing one.
+     *
+     * Pass `mergeByUid: true` to instead match (and replace, or insert if missing) by the document's `uid`, the
+     * framework's true logical primary key, regardless of whether `_id` was carried forward from a prior read.
+     * Useful for a single-row-per-uid document that may have been built fresh (e.g. by spreading an update onto
+     * a plain object) without preserving `_id`, where the default `_id`-only behavior would insert a *second*,
+     * duplicate document instead of updating the existing one (see `ACLUtils.saveACL()`).
      *
      * @param doc The document to save.
+     * @param options Driver options, plus optionally `mergeByUid` (see above).
      * @returns The saved document.
      */
-    save(doc: any): Promise<T>;
+    save(doc: any, options?: (InsertOneOptions | ReplaceOptions) & {
+        mergeByUid?: boolean;
+    }): Promise<T>;
     /**
      * Updates all documents matching the given filter with the provided update operations.
      *

package/dist/types/database/RedisCache.d.ts

@@ -0,0 +1,23 @@
+import { RedisStore } from "@rapidrest/core";
+import type { RedisClientType } from "redis";
+import { BaseEntity } from "typeorm";
+import { SimpleEntity } from "../models/SimpleEntity.js";
+/**
+ * Implements a cache system for storing entities. Uses the `cache` Redis datastore (when configured) as the
+ * backing database. Otherwise, provides an in-memory cache store for entities.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class RedisCache<T extends BaseEntity | SimpleEntity> extends RedisStore {
+    protected redisClient?: RedisClientType;
+    /** The entity type that is to be stored in this cache. */
+    protected readonly type: any;
+    constructor(type: any);
+    private init;
+    load(id: string, skipRedis?: boolean): Promise<T | undefined>;
+    loadMany(ids: string[]): Promise<(T | undefined)[]>;
+    loadSet(id: string): Promise<(T | undefined)[] | undefined>;
+    save(id: string, data: T, ttl?: number, skipRedis?: boolean): Promise<void>;
+    saveMany(ids: string[], data: T[], ttl?: number): Promise<void>;
+    saveSet(id: string, data: T[], idProp?: string, ttl?: number): Promise<void>;
+}

package/dist/types/database/TypeOrmSupport.d.ts

@@ -9,12 +9,12 @@ import * as typeorm from "typeorm";
  */
 export declare function registerFrameworkMetadata(entities: any[]): void;
 /**
- * Establishes a TypeORM connection for the given SQL datastore configuration. If a connection with the given name
+ * Establishes a TypeORM connection for the given SQL datasource configuration. If a connection with the given name
  * already exists it is reused (and reconnected if necessary).
  *
- * @param name The name of the datastore to connect to.
- * @param datastore The datastore configuration to pass to TypeORM.
+ * @param name The name of the datasource to connect to.
+ * @param datasource The datasource configuration to pass to TypeORM.
  * @param entities The list of entity classes assigned to this connection.
  * @param url The connection URL of the database.
  */
-export declare function connect(name: string, datastore: any, entities: any[], url: string): Promise<typeorm.DataSource>;
+export declare function connect(name: string, datasource: any, entities: any[], url: string): Promise<typeorm.DataSource>;

package/dist/types/database/index.d.ts

@@ -4,3 +4,4 @@ export * from "./MongoConnection.js";
 export * from "./MongoRepository.js";
 export * from "./MongoSchemaSync.js";
 export * from "./NamingUtils.js";
+export * from "./RedisCache.js";

package/dist/types/decorators/DatabaseDecorators.d.ts

@@ -1,18 +1,149 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/** The transactional context (`session` and/or `entityManager`) established by `@Transactional`, if any. */
+export interface TransactionContext {
+    /** The MongoDB-specific session object to pass in to MongoRepository for each operation. */
+    session?: any;
+    /** The TypeORM-specific entity manager to perform all operations with. */
+    entityManager?: any;
+    /** The datasource name this context's session/entityManager belongs to, used to guard merging (see `Transactional`). */
+    datasource?: string;
+    /**
+     * Best-effort compensating actions to run if this transaction ultimately fails, populated via
+     * `registerRollbackHook()`. Owned by whichever `@Transactional` call actually opened the real transaction
+     * (nested/merged calls share the same array via the ambient context, rather than each getting their own).
+     */
+    onRollback?: Array<() => Promise<void>>;
+}
 /**
- * Apply this to a property to have the TypeORM `MongoRepository` for the given entity type injected at instantiation.
+ * Carries the transactional context established by `@Transactional` through the async call chain of the
+ * decorated method, keyed to that specific invocation rather than to the object instance the method runs on.
+ */
+export declare const transactionContext: AsyncLocalStorage<TransactionContext>;
+/**
+ * Registers a best-effort compensating action to run if the currently active transaction (the one owning the
+ * ambient `transactionContext`) ultimately fails. Intended for code that just committed a write on a *different*
+ * connection than the active transaction's own (e.g. one that can't be rolled back by that transaction's own
+ * abort) and needs its own explicit cleanup to avoid an orphaned write if the active transaction later fails.
+ * A no-op if there's no active transaction to register against.
  *
- * @param {any} type The entity type whose repository will be injected.
+ * The hook is responsible for catching and logging its own errors; if it throws anyway, that's swallowed (via
+ * `Promise.allSettled`) rather than masking the original failure that triggered the rollback.
+ *
+ * @param hook The compensating action to run.
+ */
+export declare function registerRollbackHook(hook: () => Promise<void>): void;
+/**
+ * Apply this to a property to have the datasource connection with the given name injected at instantiation.
+ *
+ * @param name The name of the datasource or class type.
+ * @param required Set to `true` to indicate this injection must resolve, otherwise set to `false`. Default is `true`.
  */
-export declare function MongoRepository(type: any): (target: any, propertyKey: string | symbol) => void;
+export declare function DataSource(name: string, required?: boolean): (target: any, propertyKey: string | symbol) => void;
 /**
- * Apply this to a property to have the TypeORM `Repository` for the given entity type injected at instantiation.
+ * Injects the entity manager as the value of the decorated argument.
+ *
+ * @param name The name of the datasource or class type.
+ */
+export declare function EntityManager(nameOrType?: string | any): (target: any, propertyKey: string, index: number) => void;
+/**
+ * Injects the MongoDB session (used by @Transactional) as the value of the decorated argument.
+ */
+export declare function MongoSession(nameOrType?: string | any): (target: any, propertyKey: string, index: number) => void;
+/**
+ * Apply this to a property to have the datasource repository for the given entity type injected at instantiation.
  *
  * @param {any} type The entity type whose repository will be injected.
+ * @param required Set to `true` to indicate this injection must resolve, otherwise set to `false`. Default is `true`.
  */
-export declare function Repository(type: any): (target: any, propertyKey: string | symbol) => void;
+export declare function Repository(type: any, required?: boolean): (target: any, propertyKey: string | symbol) => void;
 /**
- * Apply this to a property to have the `Redis` connection injected at instantiation.
+ * Apply this to a property to have the `Redis` connection with the given name injected at instantiation.
+ *
+ * @param {string} name The name of the datasource connection to inject.
+ * @param required Set to `true` to indicate this injection must resolve, otherwise set to `false`. Default is `true`.
+ */
+export declare function Redis(name?: string, required?: boolean): (target: any, propertyKey: string | symbol) => void;
+/**
+ * Describes the opertaing mode for transaction support and how existing context should be
+ * reconciled. When @Transactional is used multiple times in a single callstack, the
+ * context can either be merged in a single transaction and nested.
+ */
+export declare enum TransactionalMode {
+    /** Always creates a new transactional context for the current function. */
+    CREATE = 0,
+    /** Merges existing transactional context instead of creating a new one. */
+    MERGE = 1
+}
+export interface TransactionalOptions {
+    /** The merge mode to apply when multiple transactions are declared in the same call stack. */
+    mode: TransactionalMode;
+    /** The set of options to pass to the underlying datastore driver. */
+    driverOptions?: any;
+}
+/**
+ * Apply this to perform all operations in a single transaction. The specified `source` can
+ * be the name of a connection or the class type of a persistent data model. If no `source` is specified it is inferred
+ * by lookup via `this.modelClass` which is injected when `@Model` is added to a class.
+ *
+ * For MongoDB, this has the effect of creating a new session and wrapping the function call in
+ * `session.withTransaction()`. Note that you must pass in the `session` to each `MongoRepository` function you wish
+ * to use the transaction. The `session` is automatically made available for the duration of the call via
+ * `transactionContext` (an `AsyncLocalStorage` that is scoped to this call). Optionally, it can also be injected to a
+ * function argument that is decorated with `@MongoSession`.
+ *
+ * For TypeORM, this has the effect of creating a new transaction and wrapping the function call in
+ * `datasource.transaction()`. Note that you must use the provided `EntityManager` for all database actions. The
+ * `entityManager` is automatically made available for the duration of the call via `transactionContext`. Optionally,
+ * it can be injected to a function argument that is decorated with `@EntityManager`.
+ *
+ * If `@Transactional` was already in effect earlier in the current call stack (e.g. a `RepoUtils` method called
+ * from a `ModelRoute` method that's also `@Transactional`), the existing transaction is reused by default rather
+ * than opening a second, nested one. See `TransactionalOptions.mode`.
+ *
+ * Note: A `@Transactional` method *MUST* always return a promise (e.g. is async).
+ *
+ * @example
+ * ```ts
+ * @Model(MongoModel)
+ * class MyClass {
+ *   @Repository(MongoModel)
+ *   private myRepo: MongoRepository<MongoModel>;
+ *
+ *   @Transactional()
+ *   public myFunc(obj: MongoModel, @MongoSession() session) {
+ *     await this.myRepo.save(obj, { session });
+ *   }
+ * }
+ * ```
+ * @example
+ * ```ts
+ * class MyClass {
+ *   @Repository(MongoModel)
+ *   private myRepo: MongoRepository<MongoModel>;
+ *
+ *   @Repository(MongoModel2)
+ *   private myRepo2: MongoRepository<MongoModel2>;
+ *
+ *   @Transactional(MongoModel)
+ *   public myFunc(obj: MongoModel, @MongoSession() session) {
+ *     await this.myRepo.save(obj, { session });
+ *   }
+ * }
+ * ```
+ * @example
+ * ```ts
+ * class MyClass {
+ *   @Repository(SQLModel)
+ *   private myRepo: Repository<SQLModel>;
  *
- * @param {string} name The name of the database connection to inject.
+ *   @Transactional(SQLModel)
+ *   public myFunc(obj: SQLModel, @EntityManager() em) {
+ *     await em.save(obj);
+ *   }
+ * }
+ * ```
+ * @param source The name of the datasource or the class type that a transaction will be created for. If none specified,
+ * the source is inferred using `this.modelClass`.
+ * @param options The transcation options to pass to the underlying datasource connection.
  */
-export declare function RedisConnection(name: string): (target: any, propertyKey: string | symbol) => void;
+export declare function Transactional(source?: string | any, options?: TransactionalOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/types/decorators/DocDecorators.d.ts

@@ -3,7 +3,7 @@ export interface DocumentsData {
     default?: any;
     description?: string;
     example?: any;
-    format?: 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string;
+    format?: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "date-time" | "password" | string;
     summary?: string;
     tags?: string[];
 }
@@ -36,7 +36,7 @@ export declare function Example(value: any): (target: any, propertyKey?: string)
  *
  * @param value The format of the property's property.
  */
-export declare function Format(value: 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | string): (target: any, propertyKey?: string) => void;
+export declare function Format(value: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "date-time" | "password" | string): (target: any, propertyKey?: string) => void;
 /**
  * Provides a brief summary about the class, property or function.
  *
@@ -67,3 +67,12 @@ export declare function Returns(types?: any | any[]): (target: any, propertyKey:
  * becomes `[[Array, MyClass]]`).
  */
 export declare function TypeInfo(types?: any | any[]): (target: any, propertyKey: string) => void;
+/**
+ * Retrieves the typing information of a class property or function, preferring the richer description provided by
+ * `@TypeInfo` and falling back to TypeScript's own `design:type` reflection metadata when `@TypeInfo` was not
+ * applied.
+ *
+ * @param target The class prototype (or class, for static members) to retrieve type information for.
+ * @param propertyKey The name of the property or function to retrieve type information for.
+ */
+export declare function getTypeInfo(target: any, propertyKey: string): any;