@decaf-ts/integrations 0.10.8 → 0.11.0

package/lib/types/redis/adapter.d.mts

@@ -0,0 +1,288 @@
+import "reflect-metadata";
+import { Adapter, AdapterFlags, ContextualArgs, MaybeContextualArg, RawResult } from "@decaf-ts/core";
+import { type RedisClientType } from "redis";
+import { BaseError, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { RawRedisQuery, RedisConfig, RedisContext, RedisFlags } from "./types.d.mts";
+import { RedisStatement } from "./RedisStatement.d.mts";
+import { RedisPaginator } from "./RedisPaginator.d.mts";
+import { RedisDispatch } from "./RedisDispatch.d.mts";
+import { RedisContextLock } from "./RedisContextLock.d.mts";
+/**
+ * @description Redis adapter for data persistence
+ * @summary The RedisAdapter implements the persistence layer on top of Redis
+ * (or any Redis-compatible server such as DragonflyDB). Each model table is
+ * stored as a single Redis hash whose fields are record ids and whose values are
+ * serialized records. The adapter is modelled on the core RAM adapter: raw queries
+ * load the matching table, revert every record to a model and then apply the same
+ * filtering, sorting, aggregation and pagination logic in JavaScript.
+ * `@transactional()` is backed by {@link RedisContextLock}, which buffers writes
+ * on a dedicated connection and flushes them atomically with `MULTI`/`EXEC`.
+ * @class RedisAdapter
+ * @category Redis
+ * @example
+ * ```typescript
+ * const adapter = new RedisAdapter({ url: "redis://localhost:6379" });
+ * await adapter.initialize();
+ * const repo = new (adapter.repository<User>())(User, adapter);
+ * await repo.create(new User({ name: "John" }));
+ * ```
+ */
+export declare class RedisAdapter extends Adapter<RedisConfig, RedisClientType, RawRedisQuery, RedisContext> {
+    private _redisClient?;
+    constructor(conf?: RedisConfig, alias?: string);
+    /**
+     * @description Creates operation flags with a user identity
+     * @summary Extends the base flags with a `UUID` used by the `createdBy` and
+     * `updatedBy` handlers. Defaults to the configured `user` or the current time.
+     * @template M - The model type for the operation
+     * @param {OperationKeys} operation - The operation being performed
+     * @param {Constructor<M>} model - The model constructor
+     * @param {Partial<RedisFlags>} flags - Partial flags to extend
+     * @return {Promise<RedisFlags>} The complete flags with a UUID
+     */
+    flags<M extends Model<boolean>>(operation: OperationKeys, model: Constructor<M>, flags: Partial<RedisFlags>): Promise<RedisFlags>;
+    /**
+     * @description Creates the Redis event dispatcher
+     * @return {RedisDispatch} A Redis-aware dispatch instance
+     */
+    protected Dispatch(): RedisDispatch;
+    /**
+     * @description Provides the Redis transaction lock implementation
+     * @summary Returns a fresh {@link RedisContextLock} per top-level transaction
+     * so `@transactional()` can buffer writes on a dedicated connection.
+     * @param {...any[]} args - Optional arguments forwarded to the lock
+     * @return {RedisContextLock} A fresh Redis transaction lock
+     */
+    transactionLock(...args: any[]): RedisContextLock<this>;
+    /**
+     * @description Initializes the adapter and opens the Redis connection
+     * @param {...MaybeContextualArg} args - Initialization arguments
+     * @return {Promise<void>} A promise that resolves once initialization is complete
+     */
+    initialize(...args: MaybeContextualArg<RedisContext>): Promise<void>;
+    /**
+     * @description Shuts down the adapter and closes the Redis connection
+     * @param {...MaybeContextualArg} args - Shutdown arguments
+     * @return {Promise<void>} A promise that resolves once shutdown is complete
+     */
+    shutdown(...args: MaybeContextualArg<RedisContext>): Promise<void>;
+    /**
+     * @description Builds the namespaced Redis key for a table
+     * @param {string} table - The table (model) name
+     * @return {string} The namespaced Redis hash key
+     */
+    recordKey(table: string): string;
+    /**
+     * @description Resolves the active transaction lock from a context, when present
+     * @summary Returns the {@link RedisContextLock} only while a transaction is
+     * actually open, so CRUD operations buffer their writes during a transaction and
+     * go straight to Redis otherwise.
+     * @param {RedisContext} [ctx] - The operation context
+     * @return {RedisContextLock | undefined} The active lock, when one exists
+     */
+    protected activeLock(ctx?: RedisContext): RedisContextLock | undefined;
+    /**
+     * @description Prepares a model for storage
+     * @summary Delegates to the base implementation, which extracts the primary
+     * key from the record before it is handed to {@link create}.
+     * @template M - The model type being prepared
+     * @param {M} model - The model instance to prepare
+     * @return Object containing the record, id and transient data
+     */
+    prepare<M extends Model>(model: M, ...args: [...any[], RedisContext]): {
+        record: Record<string, any>;
+        id: string;
+        transient?: Record<string, any>;
+    };
+    /**
+     * @description Converts a stored record back to a model instance
+     * @summary Delegates to the base implementation, reattaching the primary key
+     * extracted from the record's Redis hash field.
+     * @template M - The model type to revert to
+     * @param {Record<string, any>} obj - The stored record
+     * @param {Constructor<M>} clazz - The model constructor
+     * @param {PrimaryKeyType} id - The primary key value
+     * @return {M} The reconstructed model instance
+     */
+    revert<M extends Model>(obj: Record<string, any>, clazz: Constructor<M>, id: PrimaryKeyType, transient?: Record<string, any>, ...args: [...any[], RedisContext]): M;
+    /**
+     * @description Creates a new record in Redis
+     * @summary Writes the serialized record to the table hash. Inside a
+     * transaction the write is buffered (read-your-writes) instead of hitting
+     * Redis; otherwise `HSETNX` guarantees the record does not already exist.
+     * @template M - The model type
+     * @param {Constructor<M>} clazz - The model constructor
+     * @param {PrimaryKeyType} id - The unique record identifier
+     * @param {Record<string, any>} model - The record to store
+     * @return {Promise<Record<string, any>>} The stored record
+     */
+    create<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<RedisContext>): Promise<Record<string, any>>;
+    /**
+     * @description Reads a record from Redis
+     * @summary Reads the record from the table hash. Inside a transaction the
+     * buffered value wins (read-your-writes); a buffered delete is treated as a
+     * missing record.
+     * @template M - The model type
+     * @param {Constructor<M>} clazz - The model constructor
+     * @param {PrimaryKeyType} id - The unique record identifier
+     * @return {Promise<Record<string, any>>} The stored record
+     */
+    read<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<RedisContext>): Promise<Record<string, any>>;
+    /**
+     * @description Updates an existing record in Redis
+     * @summary Inside a transaction the write is buffered; otherwise the record
+     * is overwritten in place. A missing record raises a `NotFoundError`.
+     * @template M - The model type
+     * @param {Constructor<M>} clazz - The model constructor
+     * @param {PrimaryKeyType} id - The unique record identifier
+     * @param {Record<string, any>} model - The new record data
+     * @return {Promise<Record<string, any>>} The updated record
+     */
+    update<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<RedisContext>): Promise<Record<string, any>>;
+    /**
+     * @description Deletes a record from Redis
+     * @summary Inside a transaction the delete is buffered; otherwise the field
+     * is removed from the table hash immediately. A missing record raises a
+     * `NotFoundError`.
+     * @template M - The model type
+     * @param {Constructor<M>} clazz - The model constructor
+     * @param {PrimaryKeyType} id - The unique record identifier
+     * @return {Promise<Record<string, any>>} The deleted record
+     */
+    delete<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<RedisContext>): Promise<Record<string, any>>;
+    /**
+     * @description Loads every record of a table, applying buffered writes
+     * @summary Reads the table hash and merges the transaction buffer on top so a
+     * query inside a transaction observes the transaction's own writes.
+     * @param {string} table - The table (model) name
+     * @param {RedisContext} [ctx] - The operation context
+     * @return {Promise<[string, string][]>} The record id/serialized pairs
+     */
+    protected loadTable(table: string, ctx?: RedisContext): Promise<[string, string][]>;
+    /**
+     * @description Executes a raw query against Redis
+     * @summary Loads the matching table, reverts every record to a model and
+     * applies the in-memory filtering, sorting, aggregation and pagination logic.
+     * This mirrors the core RAM adapter, since Redis hashes are not queryable.
+     * @template R - The query return type
+     * @template D - Whether only documents are returned
+     * @param {RawRedisQuery<any>} rawInput - The query specification
+     * @param {D} docsOnly - Whether to return only documents (default true)
+     * @return {Promise<RawResult<R, D>>} The query result
+     */
+    raw<R, D extends boolean>(rawInput: RawRedisQuery<any>, docsOnly?: D, ...args: ContextualArgs<RedisContext>): Promise<RawResult<R, D>>;
+    /**
+     * @description Groups records by one or more attributes
+     * @summary Recursively nests groups when multiple selectors are provided; the
+     * top-level result maps each group key to the matching records (or nested groups).
+     * @param {any[]} records - The records to group
+     * @param {(keyof Model)[]} selectors - The attributes to group by
+     * @return {Record<string, any>} The grouped records keyed by normalized group keys
+     */
+    private groupRecords;
+    /**
+     * @description Normalizes a group key to a string
+     * @summary Produces a stable string key for `undefined`, `null`, symbols,
+     * objects (via JSON) and primitives.
+     * @param {any} value - The raw group key value
+     * @return {string} The normalized key
+     */
+    private normalizeGroupKey;
+    /**
+     * @description Applies skip/limit pagination over grouped results
+     * @summary Pages the group keys while preserving their associated records.
+     * @param {Record<string, any>} grouped - The grouped records
+     * @param {number} [skip] - The number of groups to skip
+     * @param {number} [limit] - The maximum number of groups to return
+     * @return {Record<string, any>} The paged groups
+     */
+    private applyGroupPagination;
+    /**
+     * @description Parses and converts errors to appropriate types
+     * @summary Returns `BaseError` instances unchanged, maps connection
+     * failures to `ConnectionError` and wraps everything else in an
+     * `InternalError`.
+     * @template V - The expected error type
+     * @param {Error} err - The error to parse
+     * @return {V} The parsed error
+     */
+    parseError<V extends BaseError>(err: Error): V;
+    /**
+     * @description Creates a new statement builder for queries
+     * @template M - The model type for the statement
+     * @param {Partial<AdapterFlags>} [overrides] - Optional adapter flag overrides
+     * @return {RedisStatement<M, any, Adapter<...>>} A new statement builder
+     */
+    Statement<M extends Model<boolean>>(overrides?: Partial<AdapterFlags>): RedisStatement<M, any, Adapter<any, any, RawRedisQuery<M>, RedisContext>>;
+    /**
+     * @description Creates a new paginator for queries
+     * @template M - The model type for the paginator
+     * @param {RawRedisQuery} query - The query to paginate
+     * @param {number} size - The page size
+     * @param {Constructor<M>} clazz - The model constructor
+     * @return {RedisPaginator<M>} A new paginator
+     */
+    Paginator<M extends Model<boolean>>(query: RawRedisQuery, size: number, clazz: Constructor<M>): RedisPaginator<M>;
+    /**
+     * @description Validates that an aggregation targets an attribute of the expected kind
+     * @summary Resolves the attribute type from the model metadata and raises a
+     * `QueryError` when the type does not satisfy the given predicate.
+     * @param {Constructor<Model>} clazz - The model constructor
+     * @param {string} field - The attribute name to validate
+     * @param {string} context - The aggregation context used in error messages
+     * @param {function(string): boolean} predicate - Type acceptance predicate
+     * @param {string} description - Human readable description of the accepted types
+     * @return {void}
+     */
+    private ensureFieldType;
+    /**
+     * @description Resolves the attribute type from the model metadata
+     * @summary Reads the metadata or design type of the attribute and normalizes it
+     * to a lowercase type name.
+     * @param {Constructor<Model>} clazz - The model constructor
+     * @param {string} field - The attribute name
+     * @return {string | undefined} The normalized attribute type, when resolvable
+     */
+    private resolveFieldType;
+    /**
+     * @description Normalizes a raw metadata type to a lowercase type name
+     * @param {any} metaType - The raw metadata type value
+     * @return {string | undefined} The normalized type name, when resolvable
+     */
+    private normalizeMetaType;
+    /**
+     * @description Whether the given type name is a numeric type
+     * @param {string} [type] - The normalized type name
+     * @return {boolean} True for "number" and "bigint"
+     */
+    private isNumericType;
+    /**
+     * @description Converts a value to a numeric value for aggregation
+     * @summary Accepts numbers and bigints (converted to `Number`) and raises a
+     * `QueryError` for any other value kind.
+     * @param {any} value - The value to convert
+     * @param {string} field - The attribute name used in error messages
+     * @param {string} context - The aggregation context used in error messages
+     * @return {number} The numeric value
+     */
+    private toNumericValue;
+    /**
+     * @description Creates the underlying Redis client
+     * @summary Returns the already connected client when one exists (including
+     * through a `for()` configuration-scoped proxy, whose own `_client` slot would
+     * otherwise be empty and build a fresh unconnected client). Otherwise builds a
+     * node-redis client from the configured URL or discrete host/port/credentials.
+     * The client is created lazily and connected by {@link initialize}.
+     * @return {RedisClientType} The Redis client
+     */
+    protected getClient(): RedisClientType;
+    /**
+     * @description Registers Redis-specific decorations for model properties
+     * @summary Configures `createdBy` and `updatedBy` handlers for the Redis
+     * flavour so those fields are populated from the context UUID.
+     * @return {void}
+     */
+    static decoration(): void;
+}

package/lib/types/redis/constants.d.cts

@@ -0,0 +1,26 @@
+/**
+ * @description Identifier for the Redis database flavour
+ * @summary Constant string that identifies the persistence adapter as "redis" for
+ * use in adapter selection and decoration. The same flavour serves Redis and any
+ * Redis-compatible server such as DragonflyDB.
+ * @const RedisFlavour
+ * @memberOf module:redis
+ */
+export declare const RedisFlavour = "redis";
+/**
+ * @description Default key namespace used by the Redis adapter
+ * @summary Every key the adapter writes is namespaced under this prefix so a
+ * single Redis database can be shared by several decaf applications without
+ * collisions.
+ * @const RedisDefaultPrefix
+ * @memberOf module:redis
+ */
+export declare const RedisDefaultPrefix = "decaf:redis";
+/**
+ * @description Redis pub/sub channel used to broadcast observer events
+ * @summary Channel on which the adapter publishes record change events so that
+ * every process sharing the database can refresh its observers.
+ * @const RedisEventsChannel
+ * @memberOf module:redis
+ */
+export declare const RedisEventsChannel = "decaf:redis:events";

package/lib/types/redis/constants.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @description Identifier for the Redis database flavour
+ * @summary Constant string that identifies the persistence adapter as "redis" for
+ * use in adapter selection and decoration. The same flavour serves Redis and any
+ * Redis-compatible server such as DragonflyDB.
+ * @const RedisFlavour
+ * @memberOf module:redis
+ */
+export declare const RedisFlavour = "redis";
+/**
+ * @description Default key namespace used by the Redis adapter
+ * @summary Every key the adapter writes is namespaced under this prefix so a
+ * single Redis database can be shared by several decaf applications without
+ * collisions.
+ * @const RedisDefaultPrefix
+ * @memberOf module:redis
+ */
+export declare const RedisDefaultPrefix = "decaf:redis";
+/**
+ * @description Redis pub/sub channel used to broadcast observer events
+ * @summary Channel on which the adapter publishes record change events so that
+ * every process sharing the database can refresh its observers.
+ * @const RedisEventsChannel
+ * @memberOf module:redis
+ */
+export declare const RedisEventsChannel = "decaf:redis:events";

package/lib/types/redis/handlers.d.cts

@@ -0,0 +1,20 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { RelationsMetadata } from "@decaf-ts/core";
+import { ContextOf, Repository } from "@decaf-ts/core";
+import type { RedisAdapter } from "./adapter.d.cts";
+/**
+ * @description Sets the created by field on a model during Redis create/update operations
+ * @summary Automatically populates a model field with the UUID from the context during create or update operations.
+ * This function is designed to be used as a handler for Redis operations to track entity creation.
+ * @template M - Type of the model being created/updated
+ * @template R - Type of the repository handling the model
+ * @param {R} this - The repository instance
+ * @param {Context} context - The operation context containing user identification
+ * @param {RelationsMetadata} data - The relations metadata
+ * @param {keyof M} key - The property key to set with the UUID
+ * @param {M} model - The model instance being created/updated
+ * @return {Promise<void>} A promise that resolves when the field has been set
+ * @function createdByOnRedisCreateUpdate
+ * @memberOf module:redis
+ */
+export declare function createdByOnRedisCreateUpdate<M extends Model, R extends Repository<M, RedisAdapter>>(this: R, context: ContextOf<R>, data: RelationsMetadata, key: keyof M, model: M): Promise<void>;

package/lib/types/redis/handlers.d.mts

@@ -0,0 +1,20 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { RelationsMetadata } from "@decaf-ts/core";
+import { ContextOf, Repository } from "@decaf-ts/core";
+import type { RedisAdapter } from "./adapter.d.mts";
+/**
+ * @description Sets the created by field on a model during Redis create/update operations
+ * @summary Automatically populates a model field with the UUID from the context during create or update operations.
+ * This function is designed to be used as a handler for Redis operations to track entity creation.
+ * @template M - Type of the model being created/updated
+ * @template R - Type of the repository handling the model
+ * @param {R} this - The repository instance
+ * @param {Context} context - The operation context containing user identification
+ * @param {RelationsMetadata} data - The relations metadata
+ * @param {keyof M} key - The property key to set with the UUID
+ * @param {M} model - The model instance being created/updated
+ * @return {Promise<void>} A promise that resolves when the field has been set
+ * @function createdByOnRedisCreateUpdate
+ * @memberOf module:redis
+ */
+export declare function createdByOnRedisCreateUpdate<M extends Model, R extends Repository<M, RedisAdapter>>(this: R, context: ContextOf<R>, data: RelationsMetadata, key: keyof M, model: M): Promise<void>;

package/lib/types/redis/index.d.cts

@@ -0,0 +1,17 @@
+/**
+ * @module integrations/redis
+ * @summary Redis (and Redis-compatible, e.g. DragonflyDB) persistence adapter.
+ * @description Re-exports the Redis adapter, repository, query statement/paginator,
+ * event dispatch, transaction lock and serialization helpers. The adapter is
+ * exported last so its side-effect registration (flavour + decorations) runs after
+ * the supporting modules are loaded.
+ */
+export * from "./constants.d.cts";
+export * from "./types.d.cts";
+export * from "./serialization.d.cts";
+export * from "./RedisContextLock.d.cts";
+export * from "./RedisDispatch.d.cts";
+export * from "./RedisStatement.d.cts";
+export * from "./RedisPaginator.d.cts";
+export * from "./handlers.d.cts";
+export * from "./adapter.d.cts";

package/lib/types/redis/index.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @module integrations/redis
+ * @summary Redis (and Redis-compatible, e.g. DragonflyDB) persistence adapter.
+ * @description Re-exports the Redis adapter, repository, query statement/paginator,
+ * event dispatch, transaction lock and serialization helpers. The adapter is
+ * exported last so its side-effect registration (flavour + decorations) runs after
+ * the supporting modules are loaded.
+ */
+export * from "./constants.d.mts";
+export * from "./types.d.mts";
+export * from "./serialization.d.mts";
+export * from "./RedisContextLock.d.mts";
+export * from "./RedisDispatch.d.mts";
+export * from "./RedisStatement.d.mts";
+export * from "./RedisPaginator.d.mts";
+export * from "./handlers.d.mts";
+export * from "./adapter.d.mts";

package/lib/types/redis/serialization.d.cts

@@ -0,0 +1,35 @@
+/**
+ * @description Marker used to encode JavaScript Date values in JSON payloads
+ * @const RedisDateMarker
+ * @memberOf module:redis
+ */
+export declare const RedisDateMarker = "__decaf_redis_date__";
+/**
+ * @description Marker used to encode JavaScript bigint values in JSON payloads
+ * @const RedisBigIntMarker
+ * @memberOf module:redis
+ */
+export declare const RedisBigIntMarker = "__decaf_redis_bigint__";
+/**
+ * @description Serializes a record for storage in Redis
+ * @summary JSON-encodes a value while preserving types that JSON cannot represent
+ * natively. `Date` instances are encoded as an ISO string under a marker key and
+ * `bigint` values are encoded as decimal strings under a marker key so they can be
+ * revived by {@link deserialize} without loss.
+ * @param {any} value - The value to serialize
+ * @return {string} The serialized JSON string
+ * @function serialize
+ * @memberOf module:redis
+ */
+export declare function serialize(value: any): string;
+/**
+ * @description Deserializes a record read from Redis
+ * @summary JSON-decodes a value produced by {@link serialize}, restoring `Date`
+ * and `bigint` instances from their marker representations.
+ * @template T - The expected result type
+ * @param {string} raw - The serialized JSON string
+ * @return {T} The deserialized value
+ * @function deserialize
+ * @memberOf module:redis
+ */
+export declare function deserialize<T = any>(raw: string): T;

package/lib/types/redis/serialization.d.mts

@@ -0,0 +1,35 @@
+/**
+ * @description Marker used to encode JavaScript Date values in JSON payloads
+ * @const RedisDateMarker
+ * @memberOf module:redis
+ */
+export declare const RedisDateMarker = "__decaf_redis_date__";
+/**
+ * @description Marker used to encode JavaScript bigint values in JSON payloads
+ * @const RedisBigIntMarker
+ * @memberOf module:redis
+ */
+export declare const RedisBigIntMarker = "__decaf_redis_bigint__";
+/**
+ * @description Serializes a record for storage in Redis
+ * @summary JSON-encodes a value while preserving types that JSON cannot represent
+ * natively. `Date` instances are encoded as an ISO string under a marker key and
+ * `bigint` values are encoded as decimal strings under a marker key so they can be
+ * revived by {@link deserialize} without loss.
+ * @param {any} value - The value to serialize
+ * @return {string} The serialized JSON string
+ * @function serialize
+ * @memberOf module:redis
+ */
+export declare function serialize(value: any): string;
+/**
+ * @description Deserializes a record read from Redis
+ * @summary JSON-decodes a value produced by {@link serialize}, restoring `Date`
+ * and `bigint` instances from their marker representations.
+ * @template T - The expected result type
+ * @param {string} raw - The serialized JSON string
+ * @return {T} The deserialized value
+ * @function deserialize
+ * @memberOf module:redis
+ */
+export declare function deserialize<T = any>(raw: string): T;

package/lib/types/redis/types.d.cts

@@ -0,0 +1,72 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { AdapterFlags, Context } from "@decaf-ts/core";
+/**
+ * @description Connection configuration accepted by {@link RedisAdapter}
+ * @summary Supports both a full connection URL and the individual host/port/
+ * credential fields. When `url` is provided it takes precedence over the
+ * discrete fields.
+ * @typedef {object} RedisConfig
+ * @property {string} [url] Full redis:// connection string
+ * @property {string} [host] Server host (defaults to localhost)
+ * @property {number} [port] Server port (defaults to 6379)
+ * @property {string} [username] ACL username
+ * @property {string} [password] ACL password
+ * @property {number} [database] Logical database index
+ * @property {string} [prefix] Key namespace (defaults to decaf:redis)
+ * @property {string} [user] Identity reported on created/updated records
+ * @memberOf module:redis
+ */
+export type RedisConfig = {
+    url?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    database?: number;
+    prefix?: string;
+    user?: string;
+};
+/**
+ * @description Adapter flags enriched with the acting user identity
+ * @summary Extends the base adapter flags with the `UUID` field used by the
+ * `createdBy`/`updatedBy` decorators.
+ * @interface RedisFlags
+ * @extends AdapterFlags
+ * @property {string} UUID Identity of the user performing the operation
+ * @memberOf module:redis
+ */
+export interface RedisFlags extends AdapterFlags {
+    UUID: string;
+}
+/**
+ * @description Contextual type used by the Redis adapter
+ * @typedef {Context<RedisFlags>} RedisContext
+ * @memberOf module:redis
+ */
+export type RedisContext = Context<RedisFlags>;
+/**
+ * @description Raw query descriptor applied in memory by the Redis adapter
+ * @summary Mirrors the in-memory query shape of the core RAM adapter. The Redis
+ * adapter loads the matching table, reverts records to models and evaluates the
+ * predicate/sort/aggregation functions in JavaScript.
+ * @typedef {object} RawRedisQuery
+ * @template M
+ * @memberOf module:redis
+ */
+export type RawRedisQuery<M extends Model = any> = {
+    select: undefined | (keyof M)[];
+    from: Constructor<M>;
+    where: (el: M) => boolean;
+    sort?: (el: M, el2: M) => number;
+    groupBy?: (keyof M)[];
+    limit?: number;
+    skip?: number;
+    count?: keyof M | null;
+    countDistinct?: keyof M;
+    min?: keyof M;
+    max?: keyof M;
+    sum?: keyof M;
+    avg?: keyof M;
+    distinct?: keyof M;
+};

package/lib/types/redis/types.d.mts

@@ -0,0 +1,72 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { AdapterFlags, Context } from "@decaf-ts/core";
+/**
+ * @description Connection configuration accepted by {@link RedisAdapter}
+ * @summary Supports both a full connection URL and the individual host/port/
+ * credential fields. When `url` is provided it takes precedence over the
+ * discrete fields.
+ * @typedef {object} RedisConfig
+ * @property {string} [url] Full redis:// connection string
+ * @property {string} [host] Server host (defaults to localhost)
+ * @property {number} [port] Server port (defaults to 6379)
+ * @property {string} [username] ACL username
+ * @property {string} [password] ACL password
+ * @property {number} [database] Logical database index
+ * @property {string} [prefix] Key namespace (defaults to decaf:redis)
+ * @property {string} [user] Identity reported on created/updated records
+ * @memberOf module:redis
+ */
+export type RedisConfig = {
+    url?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    database?: number;
+    prefix?: string;
+    user?: string;
+};
+/**
+ * @description Adapter flags enriched with the acting user identity
+ * @summary Extends the base adapter flags with the `UUID` field used by the
+ * `createdBy`/`updatedBy` decorators.
+ * @interface RedisFlags
+ * @extends AdapterFlags
+ * @property {string} UUID Identity of the user performing the operation
+ * @memberOf module:redis
+ */
+export interface RedisFlags extends AdapterFlags {
+    UUID: string;
+}
+/**
+ * @description Contextual type used by the Redis adapter
+ * @typedef {Context<RedisFlags>} RedisContext
+ * @memberOf module:redis
+ */
+export type RedisContext = Context<RedisFlags>;
+/**
+ * @description Raw query descriptor applied in memory by the Redis adapter
+ * @summary Mirrors the in-memory query shape of the core RAM adapter. The Redis
+ * adapter loads the matching table, reverts records to models and evaluates the
+ * predicate/sort/aggregation functions in JavaScript.
+ * @typedef {object} RawRedisQuery
+ * @template M
+ * @memberOf module:redis
+ */
+export type RawRedisQuery<M extends Model = any> = {
+    select: undefined | (keyof M)[];
+    from: Constructor<M>;
+    where: (el: M) => boolean;
+    sort?: (el: M, el2: M) => number;
+    groupBy?: (keyof M)[];
+    limit?: number;
+    skip?: number;
+    count?: keyof M | null;
+    countDistinct?: keyof M;
+    min?: keyof M;
+    max?: keyof M;
+    sum?: keyof M;
+    avg?: keyof M;
+    distinct?: keyof M;
+};