@elysiumjs/mnemosyne 0.2.0 → 0.4.0

package/dist/model.d.ts

@@ -8,7 +8,7 @@ import type { ColumnMetadata, ModelAdapter } from './interfaces';
  */
 export declare const createSchemaFromModel: (columns: ColumnMetadata[], { mode }?: {
     mode?: 'create' | 'update' | 'select';
-}) => import("@sinclair/typebox").TObject<{}>;
+}) => import("typebox").TObject<{}>;
 /**
  * Mixin used to create a new abstract model class.
  * @author Axel Nana <axel.nana@workbud.com>
@@ -49,15 +49,15 @@ export declare const AbstractModel: <TTable, TColumns extends Record<string, unk
     /**
      * The validation schema for creating records.
      */
-    readonly insertSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly insertSchema: import("typebox").TObject<{}>;
     /**
      * The validation schema for updating records.
      */
-    readonly updateSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly updateSchema: import("typebox").TObject<{}>;
     /**
      * The validation schema for selecting records.
      */
-    readonly selectSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly selectSchema: import("typebox").TObject<{}>;
     /**
      * Whether the model supports tenancy.
      *

package/dist/query.d.ts

@@ -0,0 +1,150 @@
+import type { TObject, TSchema } from '@elysiumjs/core';
+import type { ModelClass } from './interfaces';
+/**
+ * A filter operator of the query DSL.
+ *
+ * - `eq`, `ne`, `gt`, `gte`, `lt`, `lte`: comparisons.
+ * - `in`: one of a comma-separated list.
+ * - `contains`, `startsWith`: case-insensitive text matches.
+ * - `isNull`: `true` or `false`.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'startsWith' | 'isNull';
+/**
+ * The type of a filtered or sorted field, which decides how its query values are read.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QueryFieldType = 'string' | 'number' | 'boolean' | 'date' | 'uuid';
+/**
+ * A filterable field.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QueryFilterSpec = {
+    /** The operators the field accepts. The first one is used by `filter[field]=value`. */
+    operators: FilterOperator[];
+    /** The type of the values. Read from the model by {@link Query.define}; `string` otherwise. */
+    type?: QueryFieldType;
+    /** The model property behind the field, when it has another name. */
+    column?: string;
+};
+/**
+ * What clients may filter and sort by, and how many rows a page holds.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QuerySpec = {
+    /** The filterable fields, with their operators. */
+    filters?: Record<string, QueryFilterSpec | FilterOperator[]>;
+    /** The sortable fields. Sortable columns should not be nullable, for cursor pagination. */
+    sort?: string[];
+    /** The sort used when the query sets none, such as `-createdAt`. */
+    defaultSort?: string;
+    /** The page size: the default, and the largest a client may ask for. */
+    limit?: {
+        default?: number;
+        max?: number;
+    };
+    /** The model property that identifies rows, the tiebreaker of every sort. Defaults to `id`. */
+    key?: string;
+    /** The types of the model's properties, set by {@link Query.define}. */
+    types?: Record<string, QueryFieldType>;
+    /** The property names of the model, for sortable fields that map to another column. */
+    columns?: Record<string, string>;
+};
+/**
+ * One filter of a parsed query.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ParsedFilter = {
+    field: string;
+    column: string;
+    operator: FilterOperator;
+    value: unknown;
+};
+/**
+ * One sort key of a parsed query.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ParsedSort = {
+    field: string;
+    column: string;
+    direction: 'asc' | 'desc';
+};
+/**
+ * A query string, validated against a {@link QuerySpec}, that repositories run.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ParsedQuery = {
+    filters: ParsedFilter[];
+    /** The sort keys, ending with the row key as the tiebreaker. */
+    sort: ParsedSort[];
+    /** The values of the sort keys of the last row of the previous page. */
+    after?: unknown[];
+    limit: number;
+};
+/**
+ * A page of rows from cursor pagination.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type CursorPage<T> = {
+    data: T[];
+    /** The cursor of the next page, or `null` on the last page. */
+    nextCursor: string | null;
+};
+export declare namespace Query {
+    /**
+     * Builds a query spec for a model: the types of the filtered and sorted fields are read from
+     * the model's select schema.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param model The model class.
+     * @param spec The filters, sorts and page size.
+     * @example
+     * ```ts
+     * const PostQuery = Query.define(Post, {
+     *   filters: { status: ['eq', 'in'], createdAt: ['gte', 'lte'], title: ['contains'] },
+     *   sort: ['createdAt', 'title'],
+     *   defaultSort: '-createdAt'
+     * });
+     * ```
+     */
+    const define: <TModel extends ModelClass>(model: TModel, spec: Omit<QuerySpec, 'types'>) => QuerySpec;
+    /**
+     * The query schema of a spec, for `@Http.query()`: it documents the filters, `sort`, `cursor`,
+     * `limit` and `fields` parameters in OpenAPI.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param spec The query spec.
+     */
+    const schema: (spec: QuerySpec) => TObject;
+    /**
+     * Validates a query string against a spec.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param spec The query spec.
+     * @param query The query, as Elysia parses it (`filter[status]` keys stay flat).
+     * @returns The parsed query, for a repository's `list()`.
+     * @throws {BadRequestError} A 400 problem whose `errors` name every invalid parameter.
+     */
+    const parse: (spec: QuerySpec, query?: Record<string, unknown>) => ParsedQuery;
+    /**
+     * Builds the cursor that points after a row.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param query The parsed query, for its sort keys.
+     * @param row The last row of a page.
+     */
+    const cursorAfter: (query: ParsedQuery, row: Record<string, unknown>) => string;
+    /**
+     * Builds a page from rows fetched with one more row than the limit: the extra row only tells
+     * that a next page exists.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param query The parsed query.
+     * @param rows Up to `limit + 1` rows.
+     */
+    const page: <T extends Record<string, unknown>>(query: ParsedQuery, rows: T[]) => CursorPage<T>;
+    /**
+     * The response schema of a page of resources.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param item The schema of one row.
+     */
+    const pageSchema: <S extends TSchema>(item: S) => TObject<{
+        data: import("typebox").TArray<S>;
+        nextCursor: import("typebox").TUnion<[import("typebox").TString, import("typebox").TNull]>;
+    }>;
+}

package/dist/repository.d.ts

@@ -56,9 +56,9 @@ export declare const AbstractRepository: <TModel extends ModelClass, TConnection
      * Updates a record in the database.
      * @param id The id of the record to update.
      * @param data The data to update.
-     * @returns The updated record.
+     * @returns The updated record, or `null` if no record has that id.
      */
-    update(id: IdType, data: TModel["$inferUpdate"]): Promise<TModel["$inferSelect"]>;
+    update(id: IdType, data: TModel["$inferUpdate"]): Promise<TModel["$inferSelect"] | null>;
     /**
      * Updates all the records in the database.
      * @param data The data to update.
@@ -68,9 +68,9 @@ export declare const AbstractRepository: <TModel extends ModelClass, TConnection
     /**
      * Deletes a record from the database.
      * @param id The ID of the record to delete.
-     * @returns The deleted record.
+     * @returns The deleted record, or `null` if no record has that id.
      */
-    delete(id: IdType): Promise<TModel["$inferSelect"]>;
+    delete(id: IdType): Promise<TModel["$inferSelect"] | null>;
     /**
      * Deletes all the records from the database.
      * @returns All the deleted records.

package/dist/resource.d.ts

@@ -0,0 +1,35 @@
+import type { TObject, TSchema } from '@elysiumjs/core';
+import type { ModelClass } from './interfaces';
+/**
+ * Options of {@link ModelResource}.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @template TKey The column names of the model.
+ */
+export type ModelResourceOptions<TKey extends string = string> = {
+    /** Columns kept out of responses and of the OpenAPI document, such as `passwordHash`. */
+    hidden?: TKey[];
+    /** Only these columns are exposed. */
+    pick?: TKey[];
+    /** These columns are left out of the schema entirely. */
+    omit?: TKey[];
+    /** Extra fields the resource exposes, such as computed or related values. */
+    extend?: Record<string, TSchema>;
+};
+/**
+ * The response schema of a model: its select schema, with hidden, picked and omitted columns
+ * applied. Use it as a route's `response`: the handler can return model rows as they are, and
+ * the response holds only the exposed fields, with dates as ISO strings.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param model The model class.
+ * @param options The columns to hide, pick or omit, and extra fields.
+ * @example
+ * ```ts
+ * const UserResource = ModelResource(User, { hidden: ['passwordHash'] });
+ *
+ * @Http.get('/:id', { response: UserResource })
+ * public show(@Http.param('id') id: string) {
+ *   return this.users.find(id);
+ * }
+ * ```
+ */
+export declare const ModelResource: <TModel extends ModelClass>(model: TModel, options?: ModelResourceOptions<Extract<keyof TModel['$inferSelect'], string>>) => TObject;

package/dist/tenancy.d.ts

@@ -100,11 +100,30 @@ export declare const getCurrentTenant: () => string | null;
  * @returns The return value of the callback.
  */
 export declare const withTenant: <T>(tenant: string, callback: () => T) => T;
+/**
+ * The pattern a tenant identifier must match: 1 to 63 ASCII letters, digits, underscores or dashes,
+ * not starting with `pg_` and other than `information_schema` (in any case).
+ *
+ * Tenant identifiers become PostgreSQL schema names in schema mode, and 63 bytes is the PostgreSQL
+ * identifier limit. The pattern leaves out quotes, dots, spaces and other characters that would
+ * need escaping or change how an identifier is read, and the names of PostgreSQL system schemas.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const TENANT_ID_PATTERN: RegExp;
+/**
+ * Checks that a tenant identifier is well-formed (see {@link TENANT_ID_PATTERN}). This does not
+ * check that the tenant exists.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param tenant The tenant identifier.
+ * @returns `true` if the identifier is well-formed, `false` otherwise.
+ */
+export declare const isValidTenantId: (tenant: string) => boolean;
 /**
  * Base class for tenant-aware middleware.
  *
  * The middleware extracts the tenant identifier from an HTTP header and
- * sets `ctx.tenant`. For RLS mode, route handlers should use the driver's
+ * sets `ctx.tenant`. Identifiers must match {@link TENANT_ID_PATTERN} and be accepted by
+ * `validateTenant`, which rejects every tenant unless overridden. For RLS mode, route handlers should use the driver's
  * isolation mechanism to wrap their queries in a tenant-scoped transaction.
  *
  * @example
@@ -136,7 +155,9 @@ export declare abstract class TenantMiddleware extends Middleware {
     protected connectionName: string;
     /**
      * Validates that a tenant identifier is legitimate.
-     * Override this to check against your data store.
+     *
+     * Rejects every tenant by default: override it to check the tenant against your data store.
+     * Only identifiers matching {@link TENANT_ID_PATTERN} reach this method.
      * @author Axel Nana <axel.nana@workbud.com>
      * @param _tenant The tenant identifier to validate.
      * @returns `true` if the tenant is valid, `false` otherwise.
@@ -165,7 +186,8 @@ export declare abstract class TenantMiddleware extends Middleware {
     onRequest(ctx: Context): Promise<any>;
 }
 /**
- * A simple tenant middleware that allows public access by default.
+ * A simple tenant middleware that allows public access by default. Requests naming a tenant are
+ * rejected until `validateTenant` is overridden.
  * @author Axel Nana <axel.nana@workbud.com>
  */
 export declare class SimpleTenantMiddleware extends TenantMiddleware {

package/dist/unit-of-work.d.ts

@@ -0,0 +1,68 @@
+/** A callback run once the unit of work has committed or rolled back. */
+type Hook = () => unknown | Promise<unknown>;
+/** Runs a callback in a database transaction, joining the one open on the connection. */
+export type TransactionRunner = <T>(callback: () => Promise<T>, connection?: string) => Promise<T>;
+/**
+ * Wraps a driver's transaction function into the runner of units of work: the outermost run
+ * collects the `afterCommit` and `afterRollback` hooks of everything it calls, and runs them once
+ * it has committed or rolled back. Inner runs join it. Driver modules register the result as the
+ * `db.transaction` service, which `transactional` routes and {@link UnitOfWork.run} use.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param transaction Runs a callback in a transaction, joining an open one.
+ */
+export declare const withUnitOfWork: (transaction: TransactionRunner) => TransactionRunner;
+export declare namespace UnitOfWork {
+    /**
+     * Runs a callback in a unit of work: one transaction on the connection that every repository
+     * call made from the callback uses. When a unit of work is already open, the callback joins
+     * it, so services compose without knowing which of them opened it.
+     *
+     * A callback that returns a `DomainError` rolls the work back, like one that throws, and the
+     * error is returned. A joined callback hands it to the one that opened the unit of work, which
+     * rolls back when it returns it too.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param callback The work to run.
+     * @param options The connection of the transaction. Defaults to `default`.
+     * @throws {Error} When no database module provides the `db.transaction` service.
+     */
+    const run: <T>(callback: () => Promise<T>, options?: {
+        connection?: string;
+    }) => Promise<T>;
+    /** Whether a unit of work is open in the current async context. */
+    const active: () => boolean;
+    /**
+     * Runs a callback once the current unit of work has committed, such as publishing the events
+     * of an outbox. Outside a unit of work, it runs right away. A failing hook is logged.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param hook The callback.
+     */
+    const afterCommit: (hook: Hook) => Promise<void>;
+    /**
+     * Runs a callback if the current unit of work rolls back, such as deleting an uploaded file.
+     * Outside a unit of work, it never runs.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param hook The callback.
+     */
+    const afterRollback: (hook: Hook) => void;
+}
+/**
+ * Runs a method in a unit of work (see {@link UnitOfWork.run}): a new transaction, or the one
+ * already open. A method that returns a `DomainError` rolls back.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param options The connection of the transaction. Defaults to `default`.
+ * @example
+ * ```ts
+ * @Service.register()
+ * class TransferService {
+ *   @Transactional()
+ *   public async transfer(from: string, to: string, amount: number) {
+ *     await this.accounts.debit(from, amount);
+ *     await this.accounts.credit(to, amount);
+ *   }
+ * }
+ * ```
+ */
+export declare const Transactional: (options?: {
+    connection?: string;
+}) => MethodDecorator;
+export {};

package/package.json

@@ -1,15 +1,19 @@
 {
 	"name": "@elysiumjs/mnemosyne",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"license": "Apache-2.0",
 	"description": "Database and caching for Elysium.js applications",
 	"private": false,
 	"author": "Workbud Technologies Inc.",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/workbud/elysium"
+		"url": "git+https://github.com/na2axl/elysiumjs.git",
+		"directory": "@elysiumjs/mnemosyne"
+	},
+	"homepage": "https://github.com/na2axl/elysiumjs/tree/main/@elysiumjs/mnemosyne#readme",
+	"bugs": {
+		"url": "https://github.com/na2axl/elysiumjs/issues"
 	},
-	"homepage": "https://github.com/workbud/elysium",
 	"scripts": {
 		"format": "prettier --write \"./src/**/*.ts\"",
 		"clean": "rimraf dist",
@@ -17,7 +21,9 @@
 		"build:ts": "tsc",
 		"build": "bun run clean && bun run build:js && bun run build:ts",
 		"typecheck": "tsc --noEmit",
-		"prepublishOnly": "bun run build"
+		"prepublishOnly": "bun run build",
+		"test": "bun test",
+		"test:coverage": "bun test --coverage"
 	},
 	"keywords": [
 		"elysium",
@@ -28,12 +34,18 @@
 	"module": "dist/index.js",
 	"type": "module",
 	"types": "dist/index.d.ts",
+	"files": [
+		"dist",
+		"CHANGELOG.md"
+	],
 	"sideEffects": false,
 	"peerDependencies": {
-		"@elysiumjs/core": "^0.8.0"
+		"@elysiumjs/core": "^0.11.0",
+		"@elysiumjs/redis": "^0.1.0"
 	},
 	"devDependencies": {
-		"@elysiumjs/core": "0.8.0"
+		"@elysiumjs/core": "0.11.0",
+		"@elysiumjs/redis": "0.1.0"
 	},
 	"dependencies": {
 		"cache-manager": "^7.2.9",

package/.turbo/turbo-build.log

@@ -1,8 +0,0 @@
-$ bun run clean && bun run build:js && bun run build:ts
-$ rimraf dist
-$ bun build ./src/index.ts --outdir ./dist --target bun --packages external --root ./src --minify-syntax --minify-whitespace
-Bundled 8 modules in 21ms
-
-  index.js  11.16 KB  (entry point)
-
-$ tsc

package/src/cache.ts

@@ -1,219 +0,0 @@
-// Copyright (c) 2025-present Workbud Technologies Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import type { KeyvStoreAdapter } from 'keyv';
-
-import { Service, ServiceNotFoundError } from '@elysiumjs/core';
-import { createCache } from 'cache-manager';
-import { Keyv } from 'keyv';
-import { alphabetical } from 'radash';
-
-/** Name of the global service backing `Cache.redis`. */
-export const REDIS_CACHE_SERVICE = 'mnemosyne.cache.redis';
-
-/** Name of the global service backing `Cache.memory`. */
-export const MEMORY_CACHE_SERVICE = 'mnemosyne.cache.memory';
-
-/**
- * Interface for a cache storage.
- * @author Axel Nana <axel.nana@workbud.com>
- */
-export interface CacheInterface {
-	/**
-	 * Retrieves the cached data for a given key.
-	 * @typeParam T The type of the cached data.
-	 *
-	 * @param key The key of the cached data.
-	 */
-	get<T>(key: string): Promise<T | undefined>;
-
-	/**
-	 * Retrieves the cached data for a given list of keys.
-	 * @typeParam T The type of the cached data.
-	 *
-	 * @param keys The list of cached data keys.
-	 */
-	mget<T>(keys: string[]): Promise<Array<T | undefined>>;
-
-	/**
-	 * Gets the TTL of the cached data with the given key.
-	 * @param key The key of the cached data.
-	 * @returns The TTL of the cached data, or `undefined` if the data does not exist.
-	 */
-	ttl(key: string): Promise<number | undefined>;
-
-	/**
-	 * Caches data under the given key and an optional TTL.
-	 * @typeParam T The type of the data to cache.
-	 *
-	 * @param key The key of the cached data.
-	 * @param data The data to cache.
-	 * @param ttl The optional TTL of the cached data. If not defined, the data is cached forever.
-	 * @returns The cached data.
-	 */
-	set<T>(key: string, data: T, ttl?: number): Promise<T>;
-
-	/**
-	 * Caches data under the given list of keys and an optional TTL.
-	 * @typeParam T The type of the data to cache.
-	 *
-	 * @param data The list of data to cache.
-	 * @returns The list of cached data.
-	 */
-	mset<T>(
-		data: Array<{
-			key: string;
-			value: T;
-			ttl?: number;
-		}>
-	): Promise<
-		Array<{
-			key: string;
-			value: T;
-			ttl?: number;
-		}>
-	>;
-
-	/**
-	 * Deletes the cached data with the given key.
-	 * @typeParam T The type of the data to cache.
-	 *
-	 * @param key The key of the cached data.
-	 * @returns `true` if the data was deleted, `false` otherwise.
-	 */
-	del(key: string): Promise<boolean>;
-
-	/**
-	 * Deletes the cached data with the given list of keys.
-	 * @typeParam T The type of the data to cache.
-	 *
-	 * @param keys The list of cached data keys.
-	 * @returns `true` if the data was deleted, `false` otherwise.
-	 */
-	mdel(keys: string[]): Promise<boolean>;
-
-	/**
-	 * Deletes all cached data.
-	 * @returns `true` if the data was deleted, `false` otherwise.
-	 */
-	clear(): Promise<boolean>;
-
-	/**
-	 * Creates a sub-cache with the given tags.
-	 * @param tags The list of tags for the sub-cache.
-	 */
-	tags(...tags: string[]): Omit<CacheInterface, 'tags'>;
-}
-
-/**
- * Makes a cache interface wrapping the given store.
- * @author Axel Nana <axel.nana@workburd.com>
- * @param store The cache storage to use in the interface.
- * @returns A new `CacheInterface`.
- */
-export const makeCacheInterface = (store: KeyvStoreAdapter): CacheInterface => {
-	const base = createCache({
-		stores: [
-			new Keyv({
-				store,
-				namespace: 'cache'
-			})
-		]
-	}) as Omit<CacheInterface, 'tags'>;
-
-	const tagsCache = new Map<string, Omit<CacheInterface, 'tags'>>();
-
-	return {
-		...base,
-		tags(...tags) {
-			const namespace = `cache__${alphabetical(tags, (item) => item).join('__')}`;
-			let cache = tagsCache.get(namespace);
-
-			if (!cache) {
-				cache = createCache({
-					stores: [
-						new Keyv({
-							store,
-							namespace
-						})
-					]
-				}) as Omit<CacheInterface, 'tags'>;
-
-				tagsCache.set(namespace, cache);
-			}
-
-			return cache;
-		}
-	};
-};
-
-const getCache = (name: string): CacheInterface => {
-	const cache = Service.get<CacheInterface>(name);
-	if (!cache) throw new ServiceNotFoundError(name);
-	return cache;
-};
-
-/**
- * Static access to the caches provided by the `MnemosyneModule`.
- * @author Axel Nana <axel.nana@workbud.com>
- */
-export abstract class Cache {
-	/**
-	 * A weak cache storage for simple non-intrusive caching of data.
-	 * @author Axel Nana <axel.nana@workbud.com>
-	 */
-	public static readonly weak = Object.seal({
-		/**
-		 * INTERNAL USAGE ONLY.
-		 * @private
-		 */
-		map: new WeakMap<object, unknown>(),
-
-		/**
-		 * Gets the cached data for a given context.
-		 * @param ctx The cache context.
-		 * @returns The cached data.
-		 */
-		get<T extends object>(ctx: object): T {
-			if (!this.map.has(ctx)) this.map.set(ctx, {});
-			return this.map.get(ctx) as T;
-		},
-
-		/**
-		 * Deletes the cached data for a given context.
-		 * @param ctx The cache context.
-		 */
-		del(ctx: object): void {
-			this.map.delete(ctx);
-		}
-	});
-
-	/**
-	 * Redis-based cache storage.
-	 * @author Axel Nana <axel.nana@workbud.com>
-	 * @throws {ServiceNotFoundError} If the `MnemosyneModule` is not loaded or has no redis cache.
-	 */
-	public static get redis(): CacheInterface {
-		return getCache(REDIS_CACHE_SERVICE);
-	}
-
-	/**
-	 * Memory-based cache storage.
-	 * @author Axel Nana <axel.nana@workbud.com>
-	 * @throws {ServiceNotFoundError} If the `MnemosyneModule` is not loaded or has no memory cache.
-	 */
-	public static get memory(): CacheInterface {
-		return getCache(MEMORY_CACHE_SERVICE);
-	}
-}