@elysiumjs/core 0.3.2 → 0.4.1

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.2",
+	"version": "0.4.1",
 	"license": "Apache-2.0",
 	"description": "A super-charged web framework for Bun, built on top of ElysiaJS.",
 	"private": false,
@@ -26,10 +26,10 @@
 	"module": "index.ts",
 	"type": "module",
 	"dependencies": {
-		"@elysiajs/swagger": "^1.2.2",
-		"cache-manager": "^6.4.2",
-		"cacheable": "^1.8.10",
-		"drizzle-orm": "^0.43.1",
+		"@elysiajs/swagger": "^1.3.0",
+		"cache-manager": "^6.4.3",
+		"cacheable": "^1.9.0",
+		"drizzle-orm": "0.43.1-4aa795a",
 		"elysia": "latest",
 		"radash": "^12.1.0",
 		"reflect-metadata": "^0.2.2",
@@ -37,7 +37,7 @@
 	},
 	"devDependencies": {
 		"@ianvs/prettier-plugin-sort-imports": "^4.4.1",
-		"type-fest": "^4.40.1",
+		"type-fest": "^4.41.0",
 		"@types/bun": "latest"
 	},
 	"peerDependencies": {

package/src/app.ts

@@ -19,6 +19,7 @@ import type { DatabaseConnectionProps } from './database';
 import type { Route } from './http';
 import type { ModuleClass } from './module';
 import type { RedisConnectionProps } from './redis';
+import type { WampClientProps } from './wamp';
 
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { parseArgs } from 'node:util';
@@ -35,6 +36,7 @@ import { applyMiddlewares } from './middleware';
 import { Redis } from './redis';
 import { Service } from './service';
 import { deepMerge, Symbols } from './utils';
+import { Wamp } from './wamp';
 
 /**
  * An application plugin, consisting of a function that returns an Elysia instance.
@@ -47,6 +49,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.
 	 */
@@ -62,6 +67,21 @@ export type AppProps = {
 		port?: number;
 	};
 
+	/**
+	 * The wamp client configuration for the app.
+	 */
+	wamp?: {
+		/**
+		 * The default connection name.
+		 */
+		default: string;
+
+		/**
+		 * The list of connections.
+		 */
+		connections: Record<string, WampClientProps>;
+	};
+
 	/**
 	 * The list of modules provided the app.
 	 */
@@ -214,7 +234,10 @@ export abstract class Application extends InteractsWithConsole {
 
 		Service.instance('elysium.app', this);
 
-		const { database, redis } = Reflect.getMetadata(Symbols.app, this.constructor) as AppProps;
+		const { database, redis, wamp } = Reflect.getMetadata(
+			Symbols.app,
+			this.constructor
+		) as AppProps;
 
 		if (redis) {
 			for (const connectionName in redis.connections) {
@@ -236,6 +259,16 @@ export abstract class Application extends InteractsWithConsole {
 			}
 		}
 
+		if (wamp) {
+			for (const connectionName in wamp.connections) {
+				Wamp.registerConnection(connectionName, wamp.connections[connectionName]);
+			}
+
+			if (Wamp.connectionExists(wamp.default)) {
+				Wamp.setDefaultConnection(wamp.default);
+			}
+		}
+
 		// Run the application
 		this.run()
 			.then(() => Event.emit('elysium:app:launched', this, this))
@@ -349,6 +382,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 +522,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 +552,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,82 @@ 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> {
+		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 +208,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/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.
@@ -302,7 +334,7 @@ export namespace Http {
 		return function (target: Class<any>) {
 			async function handleHttp(): Promise<ElysiaApp> {
 				// TODO: Use the logger service here
-				console.log(`Registering HTTP route for ${props.path} using ${target.name}`);
+				console.log(`Registering HTTP controller for ${props.path} using ${target.name}`);
 				await nextTick();
 
 				props = assign({ path: '/', scope: HttpControllerScope.SERVER, tags: [] }, props);
@@ -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.status(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.status(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

@@ -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>
@@ -117,10 +126,24 @@ export abstract class Middleware {
 	/**
 	 * Gets the list of guards for the middleware.
 	 */
-	public get guards(): string[] {
+	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.