@elysiumjs/core 0.3.1 → 0.4.0

package/index.ts

@@ -14,7 +14,7 @@
 
 import './macros';
 
-export { type Elysia, t } from 'elysia';
+export { type Elysia, type TSchema, type Static, t } from 'elysia';
 export { type AppContext, type ElysiumPlugin, Application } from './src/app';
 export { Cache } from './src/cache';
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@elysiumjs/core",
-	"version": "0.3.1",
+	"version": "0.4.0",
 	"license": "Apache-2.0",
 	"description": "A super-charged web framework for Bun, built on top of ElysiaJS.",
 	"private": false,
@@ -29,7 +29,7 @@
 		"@elysiajs/swagger": "^1.2.2",
 		"cache-manager": "^6.4.2",
 		"cacheable": "^1.8.10",
-		"drizzle-orm": "^0.43.1",
+		"drizzle-orm": "0.43.1-4aa795a",
 		"elysia": "latest",
 		"radash": "^12.1.0",
 		"reflect-metadata": "^0.2.2",

package/src/app.ts

@@ -47,6 +47,9 @@ export type ElysiumPlugin = (app: Application) => Promise<AnyElysia>;
  * @author Axel Nana <axel.nana@workbud.com>
  */
 export type AppProps = {
+	// Allows to pass custom options to the application properties.
+	[key: string]: any;
+
 	/**
 	 * Enables or disables debug mode.
 	 */
@@ -349,6 +352,15 @@ export abstract class Application extends InteractsWithConsole {
 		return process.exit(0);
 	}
 
+	/**
+	 * Retrieves the configuration value for the given key.
+	 * @param key The key to retrieve the configuration value for.
+	 * @returns The configuration value for the given key, or `null` if not found.
+	 */
+	public getConfig<T>(key: keyof AppProps): T | null {
+		return Reflect.getMetadata(Symbols.app, this.constructor)?.[key] ?? null;
+	}
+
 	private async commandWork(argv: string[]) {
 		this.info('Starting worker process...');
 
@@ -480,13 +492,18 @@ export abstract class Application extends InteractsWithConsole {
 			.onError({ as: 'global' }, async (e) => {
 				if (await this.onError(e)) {
 					Event.emit('elysium:error', e);
+					this.trace({
+						name: 'HttpError',
+						message: 'Unexpected error while handling HTTP request',
+						// @ts-expect-error The stack property may not exist in the error.
+						stack: e.error.stack,
+						...e.error
+					});
 
 					let data = {};
 
 					if (typeof e.code === 'number') {
-						data = {
-							message: e.error.response
-						};
+						return e.error.response;
 					} else {
 						switch (e.code) {
 							case 'VALIDATION': {
@@ -505,54 +522,8 @@ export abstract class Application extends InteractsWithConsole {
 						}
 					}
 
-					const type = (() => {
-						if (typeof e.code === 'string') return e.code;
-						else {
-							switch (e.code) {
-								case 500:
-									return 'INTERNAL_SERVER_ERROR';
-								case 400:
-									return 'BAD_REQUEST';
-								case 401:
-									return 'UNAUTHORIZED';
-								case 403:
-									return 'FORBIDDEN';
-								case 404:
-									return 'NOT_FOUND';
-								case 405:
-									return 'METHOD_NOT_ALLOWED';
-								case 409:
-									return 'CONFLICT';
-								case 429:
-									return 'TOO_MANY_REQUESTS';
-								case 422:
-									return 'UNPROCESSABLE_ENTITY';
-								case 426:
-									return 'UPGRADE_REQUIRED';
-								case 428:
-									return 'PRECONDITION_REQUIRED';
-								case 431:
-									return 'REQUEST_HEADER_FIELDS_TOO_LARGE';
-								case 451:
-									return 'UNAVAILABLE_FOR_LEGAL_REASONS';
-								case 501:
-									return 'NOT_IMPLEMENTED';
-								case 502:
-									return 'BAD_GATEWAY';
-								case 503:
-									return 'SERVICE_UNAVAILABLE';
-								case 504:
-									return 'GATEWAY_TIMEOUT';
-								case 505:
-									return 'HTTP_VERSION_NOT_SUPPORTED';
-							}
-						}
-
-						return 'UNKNOWN';
-					})();
-
 					return {
-						type,
+						type: e.code,
 						data
 					};
 				}

package/src/cache.ts

@@ -25,7 +25,7 @@ import { KeyvRedis } from './redis';
  * Interface for a cache storage.
  * @author Axel Nana <axel.nana@workbud.com>
  */
-interface CacheInterface {
+export interface CacheInterface {
 	/**
 	 * Retrieves the cached data for a given key.
 	 * @typeParam T The type of the cached data.

package/src/console.ts

@@ -142,22 +142,26 @@ export class InteractsWithConsole {
 		// Display the title if provided
 		if (title) {
 			this.title(title);
+		} else {
+			this.newLine();
 		}
 
 		// Display the error name and message in red
 		this.write(this.format(`${errorName}: ${errorMessage}`, ConsoleFormat.RED));
 
-		// Display the stack trace in gray, each line prefixed by a tab for readability
-		this.write(this.format('Stack Trace:', ConsoleFormat.BOLD));
-		this.write(
-			this.format(
-				errorStack
-					.split('\n')
-					.map((line) => `\t${line}`)
-					.join('\n'),
-				ConsoleFormat.GRAY
-			)
-		);
+		if (error.stack) {
+			// Display the stack trace in gray, each line prefixed by a tab for readability
+			this.write(this.format('Stack Trace:', ConsoleFormat.BOLD));
+			this.write(
+				this.format(
+					errorStack
+						.split('\n')
+						.map((line) => `\t${line}`)
+						.join('\n'),
+					ConsoleFormat.GRAY
+				)
+			);
+		}
 
 		// Display any other custom properties
 		const customProps = omit(error, ['name', 'message', 'stack']);
@@ -169,6 +173,8 @@ export class InteractsWithConsole {
 				this.write(`\t${prop}: ${JSON.stringify(value)}`);
 			});
 		}
+
+		this.newLine();
 	}
 
 	/**

package/src/database.ts

@@ -14,9 +14,14 @@
 
 import type { DrizzleConfig } from 'drizzle-orm';
 import type { BunSQLDatabase } from 'drizzle-orm/bun-sql';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import type { CacheInterface } from './cache';
 
+import { getTableName, is, Table } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/bun-sql';
+import { Cache as DrizzleCache } from 'drizzle-orm/cache/core';
 
+import { Cache } from './cache';
 import { Service } from './service';
 
 /**
@@ -25,7 +30,7 @@ import { Service } from './service';
  */
 export type DatabaseConnectionProps<
 	TSchema extends Record<string, unknown> = Record<string, never>
-> = DrizzleConfig<TSchema> &
+> = Omit<DrizzleConfig<TSchema>, 'cache'> &
 	(
 		| {
 				connection:
@@ -37,7 +42,40 @@ export type DatabaseConnectionProps<
 		| {
 				client: Bun.SQL;
 		  }
-	);
+	) & {
+		/**
+		 * Configures caching behavior for the database connection.
+		 * Set it to `true` to enable caching with default configurations.
+		 */
+		cache?:
+			| true
+			| {
+					/**
+					 * Whether to enable caching.
+					 */
+					enabled?: boolean;
+
+					/**
+					 * The default TTL for cached data, in seconds.
+					 * @default 1
+					 */
+					ttl?: number;
+
+					/**
+					 * The caching strategy.
+					 * Set it to `all` to cache all queries automatically.
+					 * Set it to `explicit` to cache queries manually.
+					 * @default 'explicit'
+					 */
+					strategy?: 'explicit' | 'all';
+
+					/**
+					 * The storage engine to use.
+					 * @default 'redis'
+					 */
+					storage?: 'redis' | 'memory';
+			  };
+	};
 
 /**
  * A database connection.
@@ -47,6 +85,83 @@ export type DatabaseConnection = BunSQLDatabase<Record<string, never>> & {
 	$client: Bun.SQL;
 };
 
+/**
+ * Database cache implementation for Drizzle.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export class DatabaseCache extends DrizzleCache {
+	#cache: Omit<CacheInterface, 'tags'>;
+
+	private usedTablesPerKey: Record<string, string[]> = {};
+
+	constructor(
+		private readonly cacheStrategy: 'explicit' | 'all' = 'explicit',
+		private readonly globalTtl: number = 1,
+		storageEngine: 'redis' | 'memory' = 'redis'
+	) {
+		super();
+		this.#cache = Cache[storageEngine].tags('database');
+	}
+
+	public override strategy(): 'explicit' | 'all' {
+		return this.cacheStrategy;
+	}
+
+	public override async get(key: string): Promise<any[] | undefined> {
+		const res = (await this.#cache.get<any[]>(key)) ?? undefined;
+		return res;
+	}
+
+	public override async put(
+		key: string,
+		response: any,
+		tables: string[],
+		isTag: boolean,
+		config?: CacheConfig
+	): Promise<void> {
+		console.log({ key, response, tables, isTag, config });
+		await this.#cache.set(key, response, (config?.ex ?? this.globalTtl) * 1000);
+		for (const table of tables) {
+			const keys = this.usedTablesPerKey[table];
+			if (keys === undefined) {
+				this.usedTablesPerKey[table] = [key];
+			} else {
+				keys.push(key);
+			}
+		}
+	}
+
+	public override async onMutate(params: {
+		tags: string | string[];
+		tables: string | string[] | Table<any> | Table<any>[];
+	}): Promise<void> {
+		const tagsArray = params.tags ? (Array.isArray(params.tags) ? params.tags : [params.tags]) : [];
+		const tablesArray = params.tables
+			? Array.isArray(params.tables)
+				? params.tables
+				: [params.tables]
+			: [];
+
+		const keysToDelete = new Set<string>();
+
+		for (const table of tablesArray) {
+			const tableName = is(table, Table) ? getTableName(table) : (table as string);
+			const keys = this.usedTablesPerKey[tableName] ?? [];
+			for (const key of keys) keysToDelete.add(key);
+		}
+
+		if (keysToDelete.size > 0 || tagsArray.length > 0) {
+			await this.#cache.mdel(tagsArray);
+			await this.#cache.mdel([...keysToDelete]);
+
+			for (const table of tablesArray) {
+				const tableName = is(table, Table) ? getTableName(table) : (table as string);
+				this.usedTablesPerKey[tableName] = [];
+			}
+		}
+	}
+}
+
 export namespace Database {
 	/**
 	 * Creates a service name for a database connection.
@@ -94,7 +209,20 @@ export namespace Database {
 			process.exit(1);
 		}
 
-		return Service.instance(getConnectionName(name), drizzle(config));
+		return Service.instance(
+			getConnectionName(name),
+			drizzle({
+				...config,
+				cache:
+					config.cache === undefined
+						? undefined
+						: config.cache === true
+							? new DatabaseCache()
+							: config.cache.enabled
+								? new DatabaseCache(config.cache.strategy, config.cache.ttl, config.cache.storage)
+								: undefined
+			})
+		);
 	};
 
 	/**

package/src/env.ts

@@ -32,10 +32,14 @@ export namespace Env {
 	 * Gets the value of an environment variable.
 	 * @author Axel Nana <axel.nana@workbud.com>
 	 * @param name The name of the environment variable.
+	 * @param defaultValue The default value to return if the environment variable is not set.
 	 * @returns The value of the environment variable.
 	 */
-	export const get = <TKey extends keyof AppEnv>(name: TKey): AppEnv[TKey] => {
-		return env.get(name) as AppEnv[TKey];
+	export const get = <TKey extends keyof AppEnv>(
+		name: TKey,
+		defaultValue?: AppEnv[TKey]
+	): AppEnv[TKey] => {
+		return (env.get(name) ?? defaultValue) as AppEnv[TKey];
 	};
 
 	/**

package/src/event.ts

@@ -25,6 +25,8 @@ class EventBus extends EventEmitter {
 
 	private constructor() {
 		super();
+
+		this.on('error', (error) => this.emitError(error));
 	}
 
 	public emitError(error: unknown) {

package/src/http.ts

@@ -33,6 +33,32 @@ import { nextTick, Symbols } from './utils';
  */
 export type Route = `/${string}`;
 
+/**
+ * A class for validating data against a schema.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ValidatorClass<T extends TSchema = TSchema> = {
+	/**
+	 * The validation schema. This schema is automatically checked against the input data during
+	 * the validation stage of the HTTP request.
+	 */
+	readonly schema: T;
+
+	/**
+	 * Whether the request should be authorized before validation. If the request is not authorized,
+	 * the validation will be skipped.
+	 */
+	authorize(ctx: Context<T['static']>): Promise<boolean>;
+
+	/**
+	 * Processes custom validation logic. This method is called after the validation schema is checked
+	 * against the input data. So it's safe to assume that the schema is valid.
+	 * @param data The input data to validate.
+	 * @returns Whether the input data is valid.
+	 */
+	validate(ctx: Context<T['static']>): Promise<boolean>;
+};
+
 /**
  * A function that handles an HTTP request.
  * @author Axel Nana <axel.nana@workbud.com>
@@ -62,12 +88,12 @@ type HttpRequestHandlerMetadata = {
 	/**
 	 * The response schema.
 	 */
-	response?: TSchema;
+	response?: TSchema | Record<number, TSchema>;
 
 	/**
 	 * The request body schema.
 	 */
-	body?: { schema?: TSchema; index: number };
+	body?: { schema?: TSchema; validator?: ValidatorClass; index: number };
 
 	/**
 	 * The request query schema.
@@ -164,8 +190,14 @@ export type Singleton<TController = unknown, TModule extends Module = Module> =
  * The Elysia context with the controller injected.
  * @author Axel Nana <axel.nana@workbud.com>
  */
-export type Context<TController = unknown, TModule extends Module = Module> = ElysiaContext<
-	{},
+export type Context<
+	TBody = unknown,
+	TController = unknown,
+	TModule extends Module = Module
+> = ElysiaContext<
+	{
+		body: TBody;
+	},
 	Singleton<TController, TModule>
 >;
 
@@ -271,7 +303,7 @@ export type RequestHandlerDecoratorProps = {
 	/**
 	 * The schema of the response body.
 	 */
-	response?: TSchema;
+	response?: TSchema | Record<number, TSchema>;
 
 	/**
 	 * The operation ID for the handler.
@@ -373,6 +405,8 @@ export namespace Http {
 					const isGenerator = route.handler.constructor.name.includes('GeneratorFunction');
 					const isSSE = route.method === 'elysium:SSE';
 					const isTransactional = route.transactional ?? props.transactional ?? false;
+					const isValidator =
+						route.body && route.body.schema === undefined && route.body.validator !== undefined;
 
 					route.method = isSSE ? 'GET' : route.method;
 
@@ -439,6 +473,17 @@ export namespace Http {
 							};
 						}
 
+						if (isValidator) {
+							return async function (c: Context) {
+								if (await route.body!.validator!.validate(c)) {
+									const handler = initTransactedHandler(c);
+									return await handler(...(await getParameters(c)));
+								}
+
+								throw c.error(400, 'Invalid request body');
+							};
+						}
+
 						return async function (c: Context) {
 							const handler = initTransactedHandler(c);
 							return await handler(...(await getParameters(c)));
@@ -456,6 +501,13 @@ export namespace Http {
 					app.route(route.method, route.path, getHandler(), {
 						// @ts-ignore
 						config: {},
+						async transform(c) {
+							if (isValidator && !(await route.body!.validator!.authorize(c as Context))) {
+								throw c.error(401, 'Unauthorized');
+							}
+
+							return executeMiddlewareChain(mi, c, 'onTransform');
+						},
 						beforeHandle(c) {
 							return executeMiddlewareChain(mi, c, 'onBeforeHandle');
 						},
@@ -470,7 +522,7 @@ export namespace Http {
 							description: route.description,
 							operationId: route.operationId
 						},
-						body: route.body?.schema,
+						body: isValidator ? route.body?.validator?.schema : route.body?.schema,
 						response: route.response,
 						params: isEmpty(params) ? undefined : t.Object(params)
 					});
@@ -647,9 +699,23 @@ export namespace Http {
 	 * @author Axel Nana <axel.nana@workbud.com>
 	 * @param schema The schema of the request body.
 	 */
-	export const body = (schema?: TSchema): ParameterDecorator => {
+	export const body = (schema?: TSchema | ValidatorClass): ParameterDecorator => {
 		return function (target, propertyKey, parameterIndex) {
-			Reflect.defineMetadata('http:body', { schema, index: parameterIndex }, target, propertyKey!);
+			if (typeof schema === 'function') {
+				Reflect.defineMetadata(
+					'http:body',
+					{ validator: schema, index: parameterIndex },
+					target,
+					propertyKey!
+				);
+			} else {
+				Reflect.defineMetadata(
+					'http:body',
+					{ schema, index: parameterIndex },
+					target,
+					propertyKey!
+				);
+			}
 		};
 	};
 

package/src/middleware.ts

@@ -30,7 +30,7 @@ import { Symbols } from './utils';
 export const executeMiddlewareChain = (
 	middlewares: Middleware[],
 	context: any,
-	method: keyof Middleware
+	method: Exclude<keyof Middleware, 'guards'>
 ): Promise<any> => {
 	return Application.context.run(
 		new Map([
@@ -61,6 +61,14 @@ export const executeMiddlewareChain = (
 export const applyMiddlewares = (middlewares: Class<Middleware>[], plugin: AnyElysia) => {
 	const mi = middlewares.map((middleware) => Service.make<Middleware>(middleware));
 
+	plugin.onRequest((c) => {
+		return executeMiddlewareChain(mi, c, 'onRequest');
+	});
+
+	plugin.onTransform((c) => {
+		return executeMiddlewareChain(mi, c, 'onTransform');
+	});
+
 	plugin.onBeforeHandle((c) => {
 		return executeMiddlewareChain(mi, c, 'onBeforeHandle');
 	});
@@ -77,8 +85,9 @@ export const applyMiddlewares = (middlewares: Class<Middleware>[], plugin: AnyEl
 /**
  * Base class for middleware.
  * @author Axel Nana <axel.nana@workbud.com>
+ * @template TGuards The list of guards for the middleware.
  */
-export abstract class Middleware {
+export abstract class Middleware<TGuards extends string[] = []> {
 	/**
 	 * Registers a list of middlewares to be applied on a controller or endpoint.
 	 * @author Axel Nana <axel.nana@workbud.com>
@@ -102,6 +111,39 @@ export abstract class Middleware {
 		};
 	}
 
+	/**
+	 * Creates a guarded version of the middleware.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 * @param guards The list of guards for the middleware.
+	 * @returns A middleware class decorated with guards.
+	 */
+	public static guards(guards: string[]): Class<Middleware> {
+		class GuardedMiddleware extends this {}
+		Reflect.defineMetadata(Symbols.middlewareGuards, guards, GuardedMiddleware);
+		return GuardedMiddleware;
+	}
+
+	/**
+	 * Gets the list of guards for the middleware.
+	 */
+	public get guards(): TGuards {
+		return Reflect.getMetadata(Symbols.middlewareGuards, this.constructor) ?? [];
+	}
+
+	/**
+	 * Called first before everything else. This middleware hook works only when used on
+	 * a controller, a module, or the application.
+	 * @param ctx The request context.
+	 */
+	public onRequest(ctx: Context): any {}
+
+	/**
+	 * Called before validation, but after the request has been parsed.
+	 * Use this method to modify the request inputs before validation.
+	 * @param ctx The request context.
+	 */
+	public onTransform(ctx: Context): any {}
+
 	/**
 	 * Called after the request has been handled, but before the response is sent.
 	 * @param ctx The request context.

package/src/model.ts

@@ -12,7 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import type { PgColumn, PgColumnBuilderBase, PgSchema, PgTable } from 'drizzle-orm/pg-core';
+import type { BuildExtraConfigColumns } from 'drizzle-orm';
+import type {
+	PgColumn,
+	PgColumnBuilderBase,
+	PgSchema,
+	PgTable,
+	PgTableExtraConfigValue
+} from 'drizzle-orm/pg-core';
 import type { TSchema } from 'elysia';
 
 import { getTableConfig, pgSchema, pgTable } from 'drizzle-orm/pg-core';
@@ -65,7 +72,9 @@ const parseTypes = (element: PgColumn) => {
 	let type = (() => {
 		switch (element.dataType) {
 			case 'string':
-				return t.String();
+				return t.String({
+					format: element.columnType === 'PgUUID' ? 'uuid' : undefined
+				});
 			case 'number':
 				return t.Number();
 			case 'boolean':
@@ -89,6 +98,8 @@ const parseTypes = (element: PgColumn) => {
 
 	if (!element.notNull) {
 		type = t.Optional(type);
+	} else {
+		type = t.Required(type);
 	}
 
 	return type;
@@ -101,8 +112,9 @@ const parseTypes = (element: PgColumn) => {
  * @template TTable The drizzle's table schema wrapped by the repository.
  */
 export type ModelClass<
+	TTableName extends string,
 	TColumnsMap extends Record<string, PgColumnBuilderBase>,
-	TTable extends PgTable = ReturnType<typeof pgTable<string, TColumnsMap>>
+	TTable extends PgTable = ReturnType<typeof pgTable<TTableName, TColumnsMap>>
 > = {
 	/**
 	 * The data type returned by the select queries.
@@ -128,17 +140,24 @@ export type ModelClass<
 	/**
 	 * The name of the table wrapped by the model.
 	 */
-	readonly tableName: string;
+	readonly tableName: TTableName;
 
 	/**
 	 * The table columns configuration.
 	 */
 	readonly columns: TColumnsMap;
 
+	/**
+	 * The extra configuration for the table.
+	 */
+	readonly extraConfig?: (
+		self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>
+	) => PgTableExtraConfigValue[];
+
 	/**
 	 * The validation schema for creating records.
 	 */
-	readonly createSchema: TSchema;
+	readonly insertSchema: TSchema;
 
 	/**
 	 * The validation schema for updating records.
@@ -173,11 +192,17 @@ export type ModelClass<
  * @param tableName The name of the table.
  * @param columns The table columns configuration.
  */
-export const Model = <TColumnsMap extends Record<string, PgColumnBuilderBase>>(
-	tableName: string,
-	columns: TColumnsMap
+export const Model = <
+	TTableName extends string,
+	TColumnsMap extends Record<string, PgColumnBuilderBase>
+>(
+	tableName: TTableName,
+	columns: TColumnsMap,
+	extraConfig?: (
+		self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>
+	) => PgTableExtraConfigValue[]
 ) => {
-	const table = pgTable(tableName, columns);
+	const table = pgTable(tableName, columns, extraConfig);
 
 	class M {
 		/**
@@ -198,7 +223,7 @@ export const Model = <TColumnsMap extends Record<string, PgColumnBuilderBase>>(
 		/**
 		 * The drizzle's table schema wrapped by this model.
 		 */
-		public static get table(): ReturnType<typeof pgTable<string, TColumnsMap>> {
+		public static get table(): ReturnType<typeof pgTable<TTableName, TColumnsMap>> {
 			// If we are not inside an Application context, we can't use the tenancy system
 			if (!Application.instance || !Application.context.getStore) {
 				return table;
@@ -207,7 +232,7 @@ export const Model = <TColumnsMap extends Record<string, PgColumnBuilderBase>>(
 			if (this.supportTenancy) {
 				const tenant = Tenancy.getCurrentTenant() ?? 'public';
 				// @ts-expect-error typeof this strangely doesn't match the ModelClass type
-				return Tenancy.withTenant(tenant, this);
+				return Tenancy.wrapTenant(tenant, this);
 			}
 
 			return table;
@@ -223,10 +248,15 @@ export const Model = <TColumnsMap extends Record<string, PgColumnBuilderBase>>(
 		 */
 		public static readonly columns: TColumnsMap = columns;
 
+		/**
+		 * The extra configuration for the table.
+		 */
+		public static readonly extraConfig = extraConfig;
+
 		/**
 		 * The validation schema for creating records.
 		 */
-		public static readonly createSchema = createSchemaFromDrizzle(table, { mode: 'create' });
+		public static readonly insertSchema = createSchemaFromDrizzle(table, { mode: 'create' });
 
 		/**
 		 * The validation schema for updating records.
@@ -292,9 +322,13 @@ export namespace Tenancy {
 	 * @param model The model class that wraps the `PgTable`.
 	 * @returns The drizzle's table schema wrapped by the tenant.
 	 */
-	export const withTenant = <
-		T extends ModelClass<TColumnsMap>,
+	export const wrapTenant = <
+		T extends ModelClass<TTableName, TColumnsMap>,
+		TTableName extends string = T extends ModelClass<infer TTableName, infer TColumnsMap>
+			? TTableName
+			: string,
 		TColumnsMap extends Record<string, PgColumnBuilderBase> = T extends ModelClass<
+			TTableName,
 			infer TColumnsMap
 		>
 			? TColumnsMap
@@ -302,21 +336,21 @@ export namespace Tenancy {
 	>(
 		tenant: string,
 		model: T
-	): ReturnType<typeof pgTable<string, TColumnsMap>> => {
+	): ReturnType<typeof pgTable<TTableName, TColumnsMap>> => {
 		if (tenant === 'public') {
 			return pgTable(model.tableName, model.columns);
 		}
 
 		const tableName = `${tenant}.${model.tableName}`;
 		if (tenantSchemas.has(tableName)) {
-			return tenantSchemas.get(tableName)! as ReturnType<typeof pgTable<string, TColumnsMap>>;
+			return tenantSchemas.get(tableName)! as ReturnType<typeof pgTable<TTableName, TColumnsMap>>;
 		}
 
 		const tenantSchema = getTenantSchema(tenant);
 		const schemaTable = tenantSchema.table(model.tableName, model.columns);
 		tenantSchemas.set(tableName, schemaTable);
 
-		return schemaTable as unknown as ReturnType<typeof pgTable<string, TColumnsMap>>;
+		return schemaTable as unknown as ReturnType<typeof pgTable<TTableName, TColumnsMap>>;
 	};
 
 	/**
@@ -333,4 +367,20 @@ export namespace Tenancy {
 
 		return tenantSchema;
 	};
+
+	/**
+	 * Runs the given callback in a context with the given tenant.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 * @param tenant The name of the tenant.
+	 * @param callback The callback to run.
+	 * @returns The result of the callback.
+	 */
+	export const withTenant = <TReturn>(tenant: string, callback: () => TReturn): TReturn => {
+		const currentStore = Application.context.getStore();
+
+		const newStore = new Map(currentStore);
+		newStore.set('tenant', tenant);
+
+		return Application.context.run(newStore, callback);
+	};
 }

package/src/repository.ts

@@ -20,7 +20,6 @@ import type { DatabaseConnection } from './database';
 import type { ModelClass } from './model';
 
 import { eq } from 'drizzle-orm';
-import { pgTable } from 'drizzle-orm/pg-core';
 
 import { Application } from './app';
 import { Database } from './database';
@@ -39,9 +38,13 @@ export type IdType = number | string;
  * @template TColumnsMap The table columns config.
  */
 export interface RepositoryInterface<
-	TModel extends ModelClass<TColumnsMap>,
+	TModel extends ModelClass<TTableName, TColumnsMap>,
 	TId extends IdType = string,
+	TTableName extends string = TModel extends ModelClass<infer TTableName, infer _>
+		? TTableName
+		: string,
 	TColumnsMap extends Record<string, PgColumnBuilderBase> = TModel extends ModelClass<
+		TTableName,
 		infer TColumnsMap
 	>
 		? TColumnsMap
@@ -104,14 +107,18 @@ export interface RepositoryInterface<
  * @template TColumnsMap The table columns config.
  */
 export type RepositoryClass<
-	TModel extends ModelClass<TColumnsMap>,
+	TModel extends ModelClass<TTableName, TColumnsMap>,
 	TId extends IdType = string,
+	TTableName extends string = TModel extends ModelClass<infer TTableName, infer _>
+		? TTableName
+		: string,
 	TColumnsMap extends Record<string, PgColumnBuilderBase> = TModel extends ModelClass<
+		TTableName,
 		infer TColumnsMap
 	>
 		? TColumnsMap
 		: Record<string, PgColumnBuilderBase>
-> = Class<RepositoryInterface<TModel, TId, TColumnsMap>> & {
+> = Class<RepositoryInterface<TModel, TId, TTableName, TColumnsMap>> & {
 	/**
 	 * The drizzle's table schema wrapped by the repository.
 	 */
@@ -134,9 +141,13 @@ export type RepositoryClass<
  * @template model The model class wrapped by the repository.
  */
 export const Repository = <
-	TModel extends ModelClass<TColumnsMap>,
+	TModel extends ModelClass<TTableName, TColumnsMap>,
 	TId extends IdType = string,
+	TTableName extends string = TModel extends ModelClass<infer TTableName, infer _>
+		? TTableName
+		: string,
 	TColumnsMap extends Record<string, PgColumnBuilderBase> = TModel extends ModelClass<
+		TTableName,
 		infer TColumnsMap
 	>
 		? TColumnsMap
@@ -148,9 +159,7 @@ export const Repository = <
 	type TInsert = TModel['$inferInsert'];
 	type TUpdate = TModel['$inferUpdate'];
 
-	const table = pgTable(model.tableName, model.columns);
-
-	class R implements RepositoryInterface<TModel, TId, TColumnsMap> {
+	class R implements RepositoryInterface<TModel, TId, TTableName, TColumnsMap> {
 		/**
 		 * The drizzle's table schema wrapped by this repository.
 		 */
@@ -167,7 +176,8 @@ export const Repository = <
 		 * The database connection used by this repository.
 		 */
 		public get db(): DatabaseConnection {
-			const connection = (this.constructor as RepositoryClass<TModel, TId, TColumnsMap>).connection;
+			const connection = (this.constructor as RepositoryClass<TModel, TId, TTableName, TColumnsMap>)
+				.connection;
 			let db: DatabaseConnection | null = null;
 
 			if (connection === 'default') {
@@ -185,6 +195,25 @@ export const Repository = <
 			return await this.db.select().from(model.table);
 		}
 
+		/**
+		 * Get a paginated subset of the records in the database.
+		 * @param page The page number to retrieve.
+		 * @param count The number of records to retrieve per page.
+		 * @returns A paginated response containing the records and the total number of records.
+		 */
+		public async paginate(
+			count: number,
+			page: number = 1
+		): Promise<{ page: number; data: TSelect[]; total: number }> {
+			const total = await this.db.$count(model.table);
+			const offset = Math.max(page - 1, 0) * count;
+			return {
+				page,
+				total,
+				data: await this.db.select().from(model.table).offset(offset).limit(count)
+			};
+		}
+
 		/**
 		 * Retrieves a record by its id.
 		 * @param id The id of the record to retrieve.
@@ -195,6 +224,20 @@ export const Repository = <
 			return (row ?? null) as TSelect | null;
 		}
 
+		/**
+		 * Finds the first record with a column matching the given value.
+		 * @param column The column to filter by.
+		 * @param value The value the column should match.
+		 * @returns The first record with a column matching the given value.
+		 */
+		public async findBy<TKey extends keyof TSelect>(
+			column: TKey,
+			value: TSelect[TKey]
+		): Promise<TSelect | null> {
+			const [row] = await this.db.select().from(model.table).where(eq(model.table[column], value));
+			return (row ?? null) as TSelect | null;
+		}
+
 		/**
 		 * Inserts a new record in the database.
 		 * @param data The data to insert.

package/src/service.ts

@@ -169,15 +169,17 @@ export namespace Service {
 	/**
 	 * Resolves a registered service and set it as a parameter value.
 	 * @author Axel Nana <axel.nana@workbud.com>
-	 * @param name An optional name for the service. If not set, the name of the parameter's type is used instead.
+	 * @param service An optional name for the service. If not set, the name of the parameter's type is used instead.
 	 */
-	export const inject = (name?: string): ParameterDecorator => {
+	export const inject = (service?: string | ServiceClass): ParameterDecorator => {
 		return function (target, propertyKey, parameterIndex) {
 			const services = Reflect.getMetadata(Symbols.services, target, propertyKey!) ?? [];
-			const types = Reflect.getMetadata('design:paramtypes', target, propertyKey!) ?? [];
+			const types: Function[] =
+				Reflect.getMetadata('design:paramtypes', target, propertyKey!) ?? [];
+			const name = isString(service) ? service : (service?.name ?? types[parameterIndex].name);
 
 			services.push({
-				name: name ?? types[parameterIndex].name,
+				name,
 				index: parameterIndex
 			});
 
@@ -223,7 +225,7 @@ export namespace Service {
 			if (s === null) {
 				// TODO: Use the logger service here
 				console.error(
-					`Cannot inject a service. No service was registered with the name: ${dependency.name}`
+					`Cannot inject service ${dependency.name}. No service was registered with the name: ${dependency.name}`
 				);
 				process.exit(1);
 			}

package/src/utils.ts

@@ -17,25 +17,27 @@ import type { Elysia } from 'elysia';
 import { isObject, isPrimitive } from 'radash';
 
 export namespace Symbols {
-	export const app = Symbol('app');
+	export const app = Symbol('elysium:Application');
 
-	export const controller = Symbol('controller');
+	export const controller = Symbol('elysium:Controller');
 
-	export const middlewares = Symbol('middlewares');
+	export const middlewares = Symbol('elysium:MiddlewaresList');
 
-	export const services = Symbol('services');
+	export const services = Symbol('elysium:ServicesList');
 
-	export const websocket = Symbol('websocket');
+	export const websocket = Symbol('elysium:WebSocket');
 
-	export const wamp = Symbol('wamp');
+	export const wamp = Symbol('elysium:Wamp');
 
-	export const http = Symbol('http');
+	export const http = Symbol('elysium:Http');
 
-	export const job = Symbol('job');
+	export const job = Symbol('elysium:Job');
 
-	export const arg = Symbol('command:arguments');
+	export const arg = Symbol('elysium:CommandArguments');
 
-	export const elysiaPlugin = Symbol('elysia:plugin');
+	export const elysiaPlugin = Symbol('elysium:ElysiaPlugin');
+
+	export const middlewareGuards = Symbol('elysium:MiddlewareGuards');
 }
 
 export const nextTick = () => new Promise((resolve) => process.nextTick(resolve));

package/src/wamp.ts

@@ -90,22 +90,32 @@ export type WampProps = {
 	 * The interval to wait between retries when connecting to the WAMP server.
 	 */
 	retryInterval?: number;
+
+	/**
+	 * The authentication ID to use in challenges.
+	 */
+	authid?: string;
+
+	/**
+	 * An array of supported authentication methods.
+	 */
+	authmethods?: string[];
 };
 
 /**
  * Data sent to a WAMP RPC.
  * @author Axel Nana <axel.nana@workbud.com>
  */
-export type WampRegistrationHandlerArgs = {
+export type WampRegistrationHandlerArgs<TList = any[], TDict = any> = {
 	/**
 	 * The arguments passed to the RPC or subscription.
 	 */
-	argsList: any[];
+	argsList: TList;
 
 	/**
 	 * The keyword arguments passed to the RPC or subscription.
 	 */
-	argsDict: any;
+	argsDict: TDict;
 
 	/**
 	 * The WAMP details object.
@@ -213,6 +223,7 @@ export namespace Wamp {
 				const w = new Wampy(options.url, {
 					ws: WampWebsocket,
 					...omit(options, ['url']),
+					onChallenge: metadata.challenge?.bind(controller),
 					onClose: metadata.close?.bind(controller),
 					onError() {
 						metadata.error?.call(controller);
@@ -316,11 +327,28 @@ export namespace Wamp {
 	};
 
 	/**
-	 * Marks a method as the WAMP "open" event handler.
+	 * Marks a method as the WAMP "challenge" event handler.
+	 *
+	 * This decorator should be used on a WAMP controller method. Only one "challenge" event handler
+	 * can be defined per WAMP controller.
+	 *
 	 * @author Axel Nana <axel.nana@workbud.com>
+	 */
+	export const onChallenge = (): MethodDecorator => {
+		return function (target, _propertyKey, descriptor) {
+			const metadata = Reflect.getMetadata(Symbols.wamp, target.constructor) ?? {};
+			metadata.challenge = descriptor.value;
+			Reflect.defineMetadata(Symbols.wamp, metadata, target.constructor);
+		};
+	};
+
+	/**
+	 * Marks a method as the WAMP "open" event handler.
 	 *
 	 * This decorator should be used on a WAMP controller method. Only one "open" event handler
 	 * can be defined per WAMP controller.
+	 *
+	 * @author Axel Nana <axel.nana@workbud.com>
 	 */
 	export const onOpen = (): MethodDecorator => {
 		return function (target, _propertyKey, descriptor) {
@@ -332,10 +360,11 @@ export namespace Wamp {
 
 	/**
 	 * Marks a method as the WAMP "close" event handler.
-	 * @author Axel Nana <axel.nana@workbud.com>
 	 *
 	 * This decorator should be used on a WAMP controller method. Only one "close" event handler
 	 * can be defined per WAMP controller.
+	 *
+	 * @author Axel Nana <axel.nana@workbud.com>
 	 */
 	export const onClose = (): MethodDecorator => {
 		return function (target, _propertyKey, descriptor) {
@@ -347,10 +376,11 @@ export namespace Wamp {
 
 	/**
 	 * Marks a method as the WAMP "error" event handler.
-	 * @author Axel Nana <axel.nana@workbud.com>
 	 *
 	 * This decorator should be used on a WAMP controller method. Only one "error" event handler
 	 * can be defined per WAMP controller.
+	 *
+	 * @author Axel Nana <axel.nana@workbud.com>
 	 */
 	export const onError = (): MethodDecorator => {
 		return function (target, _propertyKey, descriptor) {
@@ -362,10 +392,11 @@ export namespace Wamp {
 
 	/**
 	 * Marks a method as the WAMP "reconnect" event handler.
-	 * @author Axel Nana <axel.nana@workbud.com>
 	 *
 	 * This decorator should be used on a WAMP controller method. Only one "reconnect" event handler
 	 * can be defined per WAMP controller.
+	 *
+	 * @author Axel Nana <axel.nana@workbud.com>
 	 */
 	export const onReconnect = (): MethodDecorator => {
 		return function (target, _propertyKey, descriptor) {
@@ -377,10 +408,11 @@ export namespace Wamp {
 
 	/**
 	 * Marks a method as the WAMP "reconnectSuccess" event handler.
-	 * @author Axel Nana <axel.nana@workbud.com>
 	 *
 	 * This decorator should be used on a WAMP controller method. Only one "reconnectSuccess" event handler
 	 * can be defined per WAMP controller.
+	 *
+	 * @author Axel Nana <axel.nana@workbud.com>
 	 */
 	export const onReconnectSuccess = (): MethodDecorator => {
 		return function (target, _propertyKey, descriptor) {

package/tsconfig.json

@@ -0,0 +1,47 @@
+// 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.
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "allowJs": true,
+    "types": [
+      "bun-types",
+      "type-fest"
+    ],
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": false,
+    "forceConsistentCasingInFileNames": true,
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noPropertyAccessFromIndexSignature": false,
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+  ],
+}