@rapidrest/service-core 1.0.0-beta.1

package/dist/types/EventListenerManager.d.ts

@@ -0,0 +1,36 @@
+import { Redis } from "ioredis";
+import { ObjectFactory } from "./ObjectFactory.js";
+/**
+ * The `EventListenerManager` is responsible for managing event handlers and processing of incoming
+ * events from the configured redis pubsub channels. An event handler is any function that has been
+ * decorated with the `@OnEvent` decorator and registered with this manager. Once registered, any event
+ * that is received corresponding to the list of types specified in the decorator arguments will be
+ * sent to the designated function(s). If no type is specified, the handler function will be called
+ * for any event that is received.
+ * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
+ */
+export declare class EventListenerManager {
+    private channels;
+    private logger;
+    private objectFactory;
+    private handlers;
+    private redis;
+    constructor(objectFactory: ObjectFactory, redis: Redis);
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    /**
+     * Handler function for events that arrive from redis.
+     */
+    private onEvent;
+    /**
+     * Adds the given function to the list of designated event handlers for the specified type.
+     * @param event The type of event to add a handler for
+     * @param func The function to add
+     */
+    private addEventHandler;
+    /**
+     * Registers the given object to be notified of events that arrive.
+     * @param obj The object to register for event handling.
+     */
+    register(obj: any): void;
+}

package/dist/types/NetUtils.d.ts

@@ -0,0 +1,29 @@
+import type { HttpRequest as XRequest } from "./http/index.js";
+/**
+ * Provides common utilities and functions for working with networking related problems.
+ *
+ * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
+ */
+export declare class NetUtils {
+    /**
+     * Performs DNS lookup of the IP address from a given url.
+     *
+     * @param url The url to lookup the IP from.
+     * @param family ip family used for dns lookup
+     * @returns A `string` containing the IP address if found, otherwise `undefined`.
+     */
+    static lookupIPAddress(url: string, family?: number): Promise<string | undefined>;
+    /**
+     * Extracts the IP address from a given url or HTTP request.
+     *
+     * When `trustedProxies` is provided, forwarding headers (`X-Forwarded-For`, etc.) are
+     * only trusted when the direct connection's `remoteAddress` is in that list. Without a
+     * trusted-proxy list the headers are ignored and the socket address is returned directly,
+     * preventing clients from spoofing their IP in audit logs.
+     *
+     * @param urlOrRequest The url or HTTP request to extract the IP from.
+     * @param trustedProxies Optional list of proxy IP addresses whose forwarding headers should be trusted.
+     * @returns A `string` containing the IP address if found, otherwise `undefined`.
+     */
+    static getIPAddress(urlOrRequest: string | XRequest, trustedProxies?: string[]): string | undefined;
+}

package/dist/types/NotificationUtils.d.ts

@@ -0,0 +1,25 @@
+import { Redis } from "ioredis";
+/**
+ * Utility functions for sending push notifications to registered clients.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class NotificationUtils {
+    /** The redis client to use for broadcasting messages. */
+    private redis;
+    /**
+     * Initializes the utility using the given redis connection.
+     *
+     * @param {any} redis The redis connection to publish to.
+     */
+    constructor(redis: Redis);
+    /**
+     * Sends a given message to the room or user with the specified uid(s).
+     *
+     * @param {string} uids The universally unique identifier of the room or user to send the message to.
+     * @param {string} type The type of message being sent.
+     * @param {string} action The action performed on the data (if applicable).
+     * @param {string} data The contents of the message to send to the room or user.
+     */
+    sendMessage(uids: string | string[], type: string, action: string, data: any): void;
+}

package/dist/types/ObjectFactory.d.ts

@@ -0,0 +1,17 @@
+import "reflect-metadata";
+import { ObjectFactory as CoreObjectFactory } from "@rapidrest/core";
+/**
+ * The `ObjectFactory` is a manager for creating objects based on registered
+ * class types. This allows for the tracking of multiple instances of objects
+ * so that references can be referenced by unique name.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class ObjectFactory extends CoreObjectFactory {
+    constructor(config?: any, logger?: any);
+    /**
+     * Scans the given object for any properties with the @Inject decorator and assigns the correct values.
+     * @param obj The object to initialize with injected defaults
+     */
+    initialize<T>(obj: any): Promise<T>;
+}

package/dist/types/OpenApiSpec.d.ts

@@ -0,0 +1,114 @@
+import { oas31 as oa } from "openapi3-ts";
+import { DocumentsData } from "./decorators/DocDecorators.js";
+/**
+ * `OpenApiSpec` is a container for an OpenAPI specification.
+ *
+ * This class wraps the behavior of openapi-ts to make it easier to build an OpenAPI
+ * specification dynamically at runtime using the server RapidREST information.
+ *
+ * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
+ */
+export declare class OpenApiSpec {
+    private _builder;
+    private config?;
+    constructor(spec?: oa.OpenAPIObject);
+    get builder(): oa.OpenApiBuilder;
+    set builder(value: oa.OpenApiBuilder);
+    get openapi(): string;
+    get info(): oa.InfoObject;
+    get servers(): oa.ServerObject[] | undefined;
+    get paths(): oa.PathsObject | undefined;
+    get components(): oa.ComponentsObject | undefined;
+    get security(): oa.SecurityRequirementObject[] | undefined;
+    get tags(): oa.TagObject[] | undefined;
+    get externalDocs(): oa.ExternalDocumentationObject | undefined;
+    get webhooks(): oa.PathsObject | undefined;
+    private init;
+    getSpec(): oa.OpenAPIObject;
+    getSpecAsJson(replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
+    getSpecAsYaml(): string;
+    addOpenApiVersion(openApiVersion: string): OpenApiSpec;
+    addInfo(info: oa.InfoObject): OpenApiSpec;
+    addContact(contact: oa.ContactObject): OpenApiSpec;
+    addLicense(license: oa.LicenseObject): OpenApiSpec;
+    addTitle(title: string): OpenApiSpec;
+    addDescription(description: string): OpenApiSpec;
+    addTermsOfService(termsOfService: string): OpenApiSpec;
+    addVersion(version: string): OpenApiSpec;
+    addPath(path: string, pathItem: oa.PathItemObject): OpenApiSpec;
+    addSchema(name: string, schema: oa.SchemaObject | oa.ReferenceObject): OpenApiSpec;
+    addResponse(name: string, response: oa.ResponseObject | oa.ReferenceObject): OpenApiSpec;
+    addParameter(name: string, parameter: oa.ParameterObject | oa.ReferenceObject): OpenApiSpec;
+    addExample(name: string, example: oa.ExampleObject | oa.ReferenceObject): OpenApiSpec;
+    addRequestBody(name: string, reqBody: oa.RequestBodyObject | oa.ReferenceObject): OpenApiSpec;
+    addHeader(name: string, header: oa.HeaderObject | oa.ReferenceObject): OpenApiSpec;
+    addSecurityScheme(name: string, secScheme: oa.SecuritySchemeObject | oa.ReferenceObject): OpenApiSpec;
+    addLink(name: string, link: oa.LinkObject | oa.ReferenceObject): OpenApiSpec;
+    addCallback(name: string, callback: oa.CallbackObject | oa.ReferenceObject): OpenApiSpec;
+    addServer(server: oa.ServerObject): OpenApiSpec;
+    addTag(tag: oa.TagObject): OpenApiSpec;
+    addExternalDocs(extDoc: oa.ExternalDocumentationObject): OpenApiSpec;
+    addWebhook(webhook: string, webhookItem: oa.PathItemObject): OpenApiSpec;
+    /**
+     * Adds a RapidREST model class to the OpenAPI specification as a schema.
+     *
+     * @param name The name of the model to add.
+     * @param clazz The class prototype to build the schema from.
+     */
+    addModel(name: string, clazz: any): OpenApiSpec;
+    /**
+     * Adds a RapidREST route handler to the OpenAPI specification.
+     *
+     * @param name The name of the route handler. (e.g. findAll)
+     * @param path The complete path of the route handler. (e.g. `/my/resources/:id`)
+     * @param method The HTTP verb type that the route handler processes. (e.g. `GET`)
+     * @param metadata The object containing all API information about the route handler.
+     * @param docs The object containing all documentation information about the route handler.
+     * @param routeClass The parent route class that the route handler belongs to.
+     */
+    addRoute(name: string, path: string, method: string, metadata: any, docs: DocumentsData, routeClass: any): OpenApiSpec;
+    /**
+     * Determines if the given type is a primitive or built-in class type.
+     * @param value
+     * @returns
+     */
+    private isBuiltInType;
+    /**
+     * Creates a new SchemaObject given the specified class prototype.
+     *
+     * @param clazz The class prototype to build a schema object from.
+     * @returns The schema object with all information derived from the given class prototype.
+     */
+    createSchemaClass(clazz: any): oa.SchemaObject;
+    /**
+     * Creates a schema object for the given type.
+     *
+     * @param typeInfo
+     * @param defaultValue
+     * @param description
+     * @param example
+     * @param format
+     * @param identifier
+     * @returns
+     */
+    createSchemaObject(typeInfo: any, defaultValue?: any, description?: string, example?: any, format?: string, identifier?: boolean): oa.SchemaObject | oa.ReferenceObject;
+    /**
+     * Returns a reference to an existing parameter defined in the OpenAPI specification for the given name.
+     *
+     * @param name The name of the parameter to find a reference for.
+     * @returns The reference to the parameter with the given name, otherwise `undefined`.
+     */
+    getParameterReference(name: string): oa.ReferenceObject | undefined;
+    /**
+     * Returns a reference to an existing schema defined in the OpenAPI specification for the given name.
+     *
+     * @param name The name of the schema to find a reference for.
+     * @returns The reference to the schema with the given name, otherwise `undefined`.
+     */
+    getSchemaReference(name: string): oa.ReferenceObject | undefined;
+    /**
+     * Merges a provided OpenAPI specification with this specification.
+     * @param other The other OpenAPI spec object to merge.
+     */
+    merge(other: any): void;
+}

package/dist/types/Server.d.ts

@@ -0,0 +1,180 @@
+import * as prom from "prom-client";
+import "reflect-metadata";
+import { ConnectionManager } from "./database/ConnectionManager.js";
+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";
+/**
+ * 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
+ * handling using JSON Web Token (JWT) directly — no Passport dependency required. When provided an OpenAPI
+ * specification object the server will also automatically serve this specification via the `GET /openapi.json` route.
+ *
+ * Routes are defined by creating any class definition using the various decorators found in `RouteDecorators` and
+ * saving these files in the `routes` subfolder. Upon server start, the `routes` folder is scanned for any class
+ * that has been decorated with `@Route` and is automatically loaded and registered. Similarly, if the
+ * class is decorated with the `@Model` decorator the resulting route object will have the associated data model
+ * definition object injected into the constructor.
+ *
+ * SSL termination is supported by providing an `ssl` configuration block with `key`, `cert`, and optionally
+ * `ca` and `passphrase` file paths. When `ssl` is present the server uses `uWS.SSLApp()`.
+ *
+ * IPv6 is supported by setting `listen_host` to `"::"` in configuration (default `"0.0.0.0"`).
+ *
+ * By default all registered endpoints that do not explicitly have an `@Auth` decorator have the `JWT`
+ * authentication strategy applied. This allows users to be implicitly authenticated without requiring additional
+ * configuration. Once authenticated, the provided `request` argument will have the `user` property available
+ * containing information about the authenticated user. If the `user` property is `undefined` then no user has
+ * been authenticated or the authentication attempt failed.
+ *
+ * The following is an example of a simple route class.
+ *
+ * ```javascript
+ * import { DefaultBehaviors, RouteDecorators } from "@rapidrest/service-core";
+ * import { Get, Route } = RouteDecorators;
+ *
+ * @Route("/hello")
+ * class TestRoute extends ModelRoute {
+ *    constructor(model: any) {
+ *        super(model);
+ *    }
+ *
+ *    @Get()
+ *    count(req: any, res: any, next: Function): any {
+ *        return res.send("Hello World!");
+ *    }
+ * }
+ *
+ * export default TestRoute;
+ * ```
+ *
+ * The following is an example of a route class that is bound to a data model providing basic CRUDS operations.
+ *
+ * ```javascript
+ * import { DefaultBehaviors, ModelDecorators, ModelRoute, RouteDecorators } from "@rapidrest/service-core";
+ * import { After, Before, Delete, Get, Post, Put, Route, Validate } = RouteDecorators;
+ * import { Model } = ModelDecorators;
+ * import { marshall } = DefaultBehaviors;
+ *
+ * @Model("Item")
+ * @Route("/items")
+ * class ItemRoute extends ModelRoute {
+ *     constructor(model: any) {
+ *       super(model);
+ *   }
+ *
+ *   @Get()
+ *   @Before(super.count)
+ *   @After(marshall)
+ *   count(req: any, res: any, next: Function): any {
+ *       return next();
+ *   }
+ *
+ *   @Post()
+ *   @Before([super.create])
+ *   @After([this.prepare, marshall])
+ *   create(req: any, res: any, next: Function): any {
+ *       return next();
+ *   }
+ *
+ *   @Delete(":id")
+ *   @Before([super.delete])
+ *   delete(req: any, res: any, next: Function): any {
+ *       return next();
+ *   }
+ *
+ *   @Get()
+ *   @Before([super.findAll])
+ *   @After(this.prepareAndSend)
+ *   findAll(req: any, res: any, next: Function): any {
+ *       return next();
+ *   }
+ *
+ *   @Get(":id")
+ *   @Before([super.findById])
+ *   @After([this.prepare, marshall])
+ *   findById(req: any, res: any, next: Function): any {
+ *       return next();
+ *   }
+ *
+ *   @Put(":id")
+ *   @Before([super.update])
+ *   @After([this.prepare, marshall])
+ *   update(req: any, res: any, next: Function): any {
+ *       return next();
+ *   }
+ * }
+ *
+ * export default ItemRoute;
+ * ```
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+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 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 manager for handling events. */
+    protected eventListenerManager?: EventListenerManager;
+    /** The logging utility to use when outputing to console/file. */
+    protected readonly logger: any;
+    /** The object factory to use when injecting dependencies. */
+    protected readonly objectFactory: ObjectFactory;
+    /** The port that the server is listening on. */
+    readonly port: number;
+    protected routeUtils?: RouteUtils;
+    protected serviceManager?: BackgroundServiceManager;
+    protected metricRequestPath: prom.Counter<string>;
+    protected metricRequestStatus: prom.Counter<string>;
+    protected metricRequestTime: prom.Histogram<string>;
+    protected metricCompletedRequests: prom.Counter<string>;
+    protected metricFailedRequests: prom.Counter<string>;
+    protected metricTotalRequests: prom.Counter<string>;
+    /**
+     * Creates a new instance of Server with the specified defaults.
+     *
+     * @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).
+     */
+    constructor(config: any, basePath?: string, logger?: any, objectFactory?: ObjectFactory);
+    /**
+     * Returns the HTTP router instance.
+     */
+    getApplication(): HttpRouter;
+    /**
+     * Returns `true` if the server is running, otherwise `false`.
+     */
+    isRunning(): boolean;
+    /**
+     * Override this function to add custom behavior before the server is started.
+     */
+    protected preStart(): void | Promise<void>;
+    /**
+     * Override this function to add custom behavior after the server is started.
+     */
+    protected postStart(): void | Promise<void>;
+    /**
+     * Starts an HTTP listen server based on the provided configuration and OpenAPI specification.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the HTTP listen server.
+     */
+    stop(): Promise<void>;
+    /**
+     * Restarts the HTTP listen server using the provided configuration and OpenAPI specification.
+     */
+    restart(): Promise<void>;
+}

package/dist/types/Types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Provides an explicit type declaration for `T | T[]`.
+ */
+export type OneOrMany<T> = T | T[];
+/**
+ * Provides an explicit type declaration for `T | null`.
+ */
+export type OneOrNull<T> = T | null;

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

@@ -0,0 +1,42 @@
+import { HttpRequest, HttpResponse, RequestHandler } from "../http/types.js";
+import { 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 authConfig;
+    private authSocketTimeout;
+    private objectFactory?;
+    /** The authentication strategies that have been registered. */
+    readonly strategies: Map<string, AuthStrategy>;
+    private init;
+    /**
+     * Performs authentication of the given request using one of the provided strategies.
+     *
+     * @param strategies The list of strategy names to attempt authentication with.
+     * @param req The request containing data to perform authenticate 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(strategies: string[], req: HttpRequest, res?: HttpResponse, required?: boolean): AuthResult | Promise<AuthResult> | undefined;
+    /**
+     * Returns a request handler function that will perform authentication of a websocket connection. Authentication
+     * can be handled in two ways:
+     *
+     * 1. Authorization header
+     * 2. Negotiation via handshake
+     *
+     * This middleware function primarily provides the implementation for item 2 above.
+     *
+     * @param required Set to `true` to indicate that auth is required, otherwise `false`.
+     */
+    authWebSocket(required: boolean): RequestHandler;
+    /**
+     * Registers the provided authentication strategy to be used
+     * @param name The name of the authentication type to associate the given strategy with
+     * @param strategy The strategy to register
+     */
+    register(name: string, strategy: AuthStrategy): void;
+}

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

@@ -0,0 +1,32 @@
+import { JWTUser } from "@rapidrest/core";
+import { HttpRequest, HttpResponse } from "../http/types.js";
+/**
+ * Result returned by `AuthStrategy.authenticate()`.
+ */
+export interface AuthResult {
+    /** The raw auth data that was verified. */
+    data?: string;
+    /** The name of the auth strategy that produced this result. */
+    method: string;
+    /** The fully decoded payload from the auth data. */
+    payload?: any;
+    /** The authenticated user profile, or `undefined` if authentication failed. */
+    user?: JWTUser;
+}
+/**
+ * Describes an interface for implementing strategies that will perform authentication.
+ */
+export interface AuthStrategy {
+    /** The unique name of the strategy used to register with the `AuthMiddleware`. */
+    readonly name: string;
+    /**
+     * 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`
+     * throws an error, otherwise returns `undefined`.
+     *
+     * @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): AuthResult | Promise<AuthResult> | undefined;
+}

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

@@ -0,0 +1,33 @@
+import { JWTUser } from "@rapidrest/core";
+import { HttpRequest, HttpResponse } from "../http/types.js";
+import { AuthResult, AuthStrategy } from "./AuthStrategy.js";
+/**
+ * Describes the configuration options that can be used to initialize BasicStrategy.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class BasicStrategyOptions {
+    /** The name of the header to look for when performing header based authentication. Default value is `Authorization`. */
+    headerKey: string;
+    /** The authorization scheme type when using header based authentication. Default value is `jwt`. */
+    headerScheme: string;
+    /** The name of the request query parameter to retrieve the token from when using query based authentication. Default value is `auth_basic`. */
+    queryKey: string;
+    /**
+     * Set to `true` to allow credentials to be supplied via the `queryKey` URL parameter.
+     * Disabled by default — query parameters appear in server logs, browser history, and
+     * Referer headers, which permanently exposes credentials outside the application.
+     */
+    allowQueryParam: boolean;
+    /** You must override this function to perform verification of the login information. */
+    verify(uid: string, secret: string): JWTUser | Promise<JWTUser> | undefined;
+}
+/**
+ * @author Jean-Philippe Steinmetz <rapidrests@gmail.com>
+ */
+export declare class BasicStrategy implements AuthStrategy {
+    readonly name: string;
+    private options;
+    constructor(options?: BasicStrategyOptions);
+    authenticate(req: HttpRequest, res: HttpResponse, required?: boolean): AuthResult | Promise<AuthResult> | undefined;
+}

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

@@ -0,0 +1,61 @@
+import { JWTUtilsConfig } from "@rapidrest/core";
+import type { HttpRequest, HttpResponse } from "../http/types.js";
+import { AuthResult } from "./AuthStrategy.js";
+/**
+ * Describes the configuration options that can be used to initialize JWTStrategy.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class JWTStrategyOptions {
+    /** The configuration options to pass to the JWTUtils library during token verification. */
+    config?: JWTUtilsConfig;
+    /** The name of the header to look for when performing header based authentication. Default value is `Authorization`. */
+    headerKey: string;
+    /** The authorization scheme type when using header based authentication. Default value is `jwt`. */
+    headerScheme: string;
+    /** The name of the cookie to retrieve the token from when using cookie based authentication. Default value is `jwt`. */
+    cookieName: string;
+    /** The name of the secured cookie to retreive the token from when using cookie based authentication. */
+    cookieSecure: boolean;
+    /** The name of the request query parameter to retrieve the token from when using query based authentication. Default value is `auth_token`. */
+    queryKey: string;
+    /**
+     * Set to `true` to allow tokens to be supplied via the `queryKey` URL parameter.
+     * Disabled by default — query parameters appear in server logs, browser history, and
+     * Referer headers, which permanently exposes tokens outside the application.
+     */
+    allowQueryParam: boolean;
+}
+/** Result returned by `JWTStrategy.authenticate()`. */
+export interface JWTAuthResult extends AuthResult {
+    /**
+     * `true` when at least one credential (header, query param, or cookie) was present in
+     * the request, even if it was ultimately invalid. Distinguishes "no token submitted" from
+     * "bad token submitted" — useful for deciding whether to reject early vs. fall through to
+     * an alternative auth path (e.g. WebSocket message-based LOGIN).
+     */
+    tokenFound?: boolean;
+}
+/**
+ * JWT authentication strategy. Performs JWT verification and searches for a token by one of the
+ * following methods (in order of precedence):
+ * * Query Parameter
+ * * Authorization Header
+ * * Cookie
+ *
+ * This class no longer extends `passport-strategy`; it is used directly by route middleware
+ * and returns a plain result object instead of calling Passport callbacks.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class JWTStrategy {
+    private config;
+    readonly name: string;
+    private options;
+    constructor(options?: JWTStrategyOptions);
+    /**
+     * Attempts to authenticate the incoming request by extracting and verifying a JWT token.
+     * Returns a `JWTAuthResult` describing the outcome.
+     */
+    authenticate(req: HttpRequest, res: HttpResponse, required?: boolean): JWTAuthResult | undefined;
+}

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

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

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

@@ -0,0 +1,7 @@
+/**
+ * Determines whether the given connection object is a TypeORM `DataSource` for a SQL database. This check is
+ * performed without importing the optional `typeorm` package by duck-typing the connection object.
+ *
+ * @param conn The connection object to inspect.
+ */
+export declare function isSqlDataSource(conn: any): boolean;

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

@@ -0,0 +1,35 @@
+import { Redis } from "ioredis";
+import type { DataSource } from "typeorm";
+import { MongoConnection } from "./MongoConnection.js";
+/**
+ * Provides database connection management.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class ConnectionManager {
+    connections: Map<string, DataSource | MongoConnection | Redis>;
+    private logger;
+    /**
+     * Builds a compatible connection URI for the database by the provided configuration.
+     */
+    private buildConnectionUri;
+    /**
+     * 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.
+     */
+    private importOptionalDependency;
+    /**
+     * Attempts to initiate all database connections as defined in the config.
+     *
+     * @param datastores A map of configured datastores to be passed to the underlying engine.
+     * @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>;
+    /**
+     * Attempts to disconnect all active database connections.
+     */
+    disconnect(): Promise<void>;
+}