@elysiumjs/core 0.4.0 → 0.4.2

package/package.json

@@ -1,13 +1,10 @@
 {
 	"name": "@elysiumjs/core",
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"license": "Apache-2.0",
 	"description": "A super-charged web framework for Bun, built on top of ElysiaJS.",
 	"private": false,
-	"author": {
-		"name": "Axel Nana",
-		"email": "axel.nana@workbud.com"
-	},
+	"author": "Workbud Technologies Inc.",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/Workerly/elysium"
@@ -26,9 +23,9 @@
 	"module": "index.ts",
 	"type": "module",
 	"dependencies": {
-		"@elysiajs/swagger": "^1.2.2",
-		"cache-manager": "^6.4.2",
-		"cacheable": "^1.8.10",
+		"@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",
@@ -37,7 +34,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.
@@ -65,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.
 	 */
@@ -217,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) {
@@ -239,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))

package/src/database.ts

@@ -119,7 +119,6 @@ export class DatabaseCache extends DrizzleCache {
 		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];

package/src/http.ts

@@ -334,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);
@@ -346,9 +346,9 @@ export namespace Http {
 
 				if (props.scope === HttpControllerScope.SERVER) {
 					const controller = Service.make(target);
-					app.decorate('controller', () => controller);
+					app.resolve({ as: 'local' }, () => ({ controller: () => controller }));
 				} else if (props.scope === HttpControllerScope.REQUEST) {
-					app.decorate('controller', () => Service.make(target));
+					app.resolve({ as: 'local' }, () => ({ controller: () => Service.make(target) }));
 				}
 
 				const onRequest = Reflect.getMetadata('http:onRequest', target) ?? {};
@@ -480,7 +480,7 @@ export namespace Http {
 									return await handler(...(await getParameters(c)));
 								}
 
-								throw c.error(400, 'Invalid request body');
+								throw c.status(400, 'Invalid request body');
 							};
 						}
 
@@ -503,7 +503,7 @@ export namespace Http {
 						config: {},
 						async transform(c) {
 							if (isValidator && !(await route.body!.validator!.authorize(c as Context))) {
-								throw c.error(401, 'Unauthorized');
+								throw c.status(401, 'Unauthorized');
 							}
 
 							return executeMiddlewareChain(mi, c, 'onTransform');

package/src/module.ts

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import type { Class } from 'type-fest';
-import type { Route } from './http';
+import type { ElysiaApp, Route } from './http';
 
 import { Elysia } from 'elysia';
 import { assign } from 'radash';
@@ -30,6 +30,12 @@ export type ModuleProps = {
 	 * The list of controllers provided by the module.
 	 */
 	controllers?: Class<any>[];
+
+	/**
+	 * The base path for all the controllers registered by this module.
+	 * This value will be prefixed to each controllers path.
+	 */
+	prefix?: Route;
 };
 
 /**
@@ -52,15 +58,15 @@ export abstract class Module {
 	 */
 	public static register(options: ModuleProps = {}) {
 		return function (target: ModuleClass) {
-			async function handleModule(m: Module): Promise<Elysia<Route>> {
+			async function handleModule(m: Module): Promise<ElysiaApp> {
 				// TODO: Use the logger service here
 				console.log(`Registering module ${target.name}`);
 				await nextTick();
 
 				const props = assign({ controllers: [] }, options) as Required<ModuleProps>;
 
-				const plugin: Elysia<Route> = new Elysia({ name: target.name });
-				plugin.decorate('module', m);
+				const plugin: ElysiaApp = new Elysia({ name: target.name, prefix: options.prefix });
+				plugin.resolve({ as: 'local' }, () => ({ module: m }));
 
 				const middlewares = Reflect.getMetadata(Symbols.middlewares, target) ?? [];
 				applyMiddlewares(middlewares, plugin);
@@ -70,7 +76,7 @@ export abstract class Module {
 					if (app === undefined) {
 						// TODO: Use the logger service here
 						console.error(
-							`Invalid controller class ${controller.name} registered in module ${target.name}. Ensure that you either used the @http(), or @websocket() decorators on the controller.`
+							`Invalid controller class ${controller.name} registered in module ${target.name}. Ensure that you either used the @Http.controller(), the @Websocket.controller(), or the @Wamp.controller() decorators on the class.`
 						);
 						process.exit(1);
 					} else {

package/src/redis.ts

@@ -342,7 +342,7 @@ export namespace Redis {
 		if (!Service.exists(getConnectionName(name))) {
 			// TODO: Use logger service here
 			console.error(
-				`No connection with name ${name} found. Please make sure to register the connection before using it.`
+				`No Redis connection with name ${name} found. Please make sure to register the connection before using it.`
 			);
 			process.exit(1);
 		}
@@ -352,11 +352,12 @@ export namespace Redis {
 
 	/**
 	 * Creates and registers a new redis connection.
-	 * @author Axel Nana <axel.nana@workbud.com>
 	 *
 	 * This will make the registered connection available for dependency injection with
 	 * the key `redis.connection.{name}`, where `{name}` is replaced with the given name.
 	 *
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 *
 	 * @param name The name of the connection.
 	 * @param config The configuration for the redis connection.
 	 * @returns The newly created and registered redis connection.
@@ -364,7 +365,7 @@ export namespace Redis {
 	export const registerConnection = (name: string, config: RedisConnectionProps) => {
 		if (Service.exists(getConnectionName(name))) {
 			// TODO: Use logger service here
-			console.error(`A connection with the name ${name} has already been registered.`);
+			console.error(`A Redis connection with the name ${name} has already been registered.`);
 			process.exit(1);
 		}
 

package/src/wamp.ts

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import type { Class } from 'type-fest';
+import type { Class, Primitive } from 'type-fest';
 
 import { Elysia } from 'elysia';
 import { omit } from 'radash';
@@ -66,6 +66,18 @@ export type WampSubscriptionOptions = Omit<WampRegistrationOptions, 'invoke'>;
  * @author Axel Nana <axel.nana@workbud.com>
  */
 export type WampProps = {
+	/**
+	 * The name of the connection to use. This connection must be registered in the application properties.
+	 * @default 'default'
+	 */
+	connection?: string;
+};
+
+/**
+ * Properties required when declaring a WAMP client in the application properties.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type WampClientProps = {
 	/**
 	 * The URL to the WAMP server.
 	 */
@@ -100,6 +112,131 @@ export type WampProps = {
 	 * An array of supported authentication methods.
 	 */
 	authmethods?: string[];
+
+	/**
+	 * Callback for handling WAMP authentication challenges.
+	 * @param method The authentication method.
+	 * @param extra Authentication metadata.
+	 */
+	onChallenge?(method: string, extra: any): string | null;
+
+	/**
+	 * Callback for handling the WAMP connection open event.
+	 */
+	onOpen?(): void;
+
+	/**
+	 * Callback for handling the WAMP connection close event.
+	 */
+	onClose?(): void;
+
+	/**
+	 * Callback for handling the WAMP connection error event.
+	 */
+	onError?(): void;
+
+	/**
+	 * Callback for handling the WAMP connection reconnect event.
+	 */
+	onReconnect?(): void;
+
+	/**
+	 * Callback for handling the WAMP connection reconnect success event.
+	 */
+	onReconnectSuccess?(): void;
+};
+
+export type WampClient = {
+	/**
+	 * Disconnects from WAMP server. Clears all queues, subscriptions and calls.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 */
+	disconnect(): Promise<void>;
+
+	subscribe(
+		topic: string,
+		handler: WampSubscriptionHandler,
+		options?: WampSubscriptionOptions
+	): Promise<{
+		topic: string;
+		requestId: string;
+		subscriptionId: string;
+		subscriptionKey: string;
+	}>;
+
+	unsubscribe(
+		subscriptionIdOrKey: string,
+		handler?: WampSubscriptionHandler
+	): Promise<{
+		topic: string;
+		requestId: string;
+	}>;
+
+	publish(
+		topic: string,
+		params?:
+			| Primitive
+			| Array<any>
+			| Record<string, Primitive | Array<any>>
+			| { argsList: Array<any>; argsDict: Record<string, any> },
+		options?: {
+			exclude?: number | number[];
+			exclude_authid?: string | string[];
+			exclude_authrole?: string | string[];
+			eligible?: number | number[];
+			eligible_authid?: string | string[];
+			eligible_authrole?: string | string[];
+			exclude_me?: boolean;
+			disclose_me?: boolean;
+			ppt_scheme?: string;
+			ppt_serializer?: string;
+			ppt_cipher?: string;
+			ppt_keyid?: string;
+		}
+	): Promise<{
+		topic: string;
+		requestId: string;
+		publicationId: string;
+	}>;
+
+	call(
+		procedure: string,
+		params?:
+			| Primitive
+			| Array<any>
+			| Record<string, Primitive | Array<any>>
+			| { argsList: Array<any>; argsDict: Record<string, any> },
+		options?: {
+			disclose_me?: boolean;
+			progress_callback?(args: { argsList: Array<any>; argsDict: Record<string, any> }): void;
+			timeout?: number;
+			ppt_scheme?: string;
+			ppt_serializer?: string;
+			ppt_cipher?: string;
+			ppt_keyid?: string;
+		}
+	): Promise<{
+		details: Record<string, any>;
+		argsList?: Array<any>;
+		argsDict?: Record<string, any>;
+	}>;
+
+	cancel(requestId: string, options?: { mode?: 'kill' | 'killnowait' | 'skip' }): true;
+
+	register(
+		topic: string,
+		handler: WampRegistrationHandler,
+		options?: WampRegistrationOptions
+	): Promise<{
+		topic: string;
+		requestId: string;
+		registrationId: string;
+	}>;
+
+	unregister(registrationId: string): Promise<{
+		topic: string;
+		requestId: string;
+	}>;
 };
 
 /**
@@ -204,6 +341,127 @@ type WampSubscription = {
 };
 
 export namespace Wamp {
+	/**
+	 * Creates a service name for a WAMP connection.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 * @param name The name of the connection.
+	 * @returns A service name for the connection.
+	 */
+	const getConnectionName = (name: string) => {
+		return `wamp.connection.${name}`;
+	};
+
+	/**
+	 * Retrieves the client for a WAMP connection.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 * @param name The name of the connection.
+	 * @returns The Wampy client for the connection with the given name.
+	 */
+	export const getConnection = (name: string) => {
+		if (!Service.exists(getConnectionName(name))) {
+			// TODO: Use logger service here
+			console.error(
+				`No WAMP connection with name ${name} found. Please make sure to register the connection before using it.`
+			);
+			process.exit(1);
+		}
+
+		return Service.get<WampClient>(getConnectionName(name))!;
+	};
+
+	/**
+	 * Creates and registers a new WAMP client.
+	 *
+	 * This will make the registered connection available for dependency injection with
+	 * the key `wamp.connection.{name}`, where `{name}` is replaced with the given name.
+	 *
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 *
+	 * @param name The name of the connection.
+	 * @param config The configuration for the WAMP client.
+	 * @returns The newly created and configured WAMP client for the given connection.
+	 */
+	export const registerConnection = (name: string, config: WampClientProps) => {
+		if (Service.exists(getConnectionName(name))) {
+			// TODO: Use logger service here
+			console.error(
+				`A WAMP connection with name ${name} already exists. Please ensure to register a new connection before overwriting it.`
+			);
+			process.exit(1);
+		}
+
+		const client = new Wampy(config.url, {
+			ws: WampWebsocket,
+			...omit(config, ['url']),
+			onError() {
+				config.onError?.();
+				// TODO: Add more details like controller name and url
+				Event.emit('elysium:error', new Error(`An error occurred in WAMP connection ${name}`));
+			}
+		});
+
+		const maxRetries = config.maxRetries ?? 5;
+		const retryInterval = config.retryInterval ?? 5000;
+		let retryCount = 0;
+
+		const tryConnect = async () => {
+			try {
+				await client.connect();
+			} catch (e) {
+				console.error(
+					`Failed to connect to WAMP server (attempt ${retryCount + 1}/${maxRetries}):`,
+					e
+				);
+
+				if (retryCount < maxRetries) {
+					retryCount++;
+					setTimeout(tryConnect, retryInterval);
+				} else {
+					console.error(`Max retry attempts (${maxRetries}) reached. Giving up.`);
+					Event.emit(
+						'elysium:error',
+						new Error(`Failed to establish WAMP connection ${name} after ${maxRetries} attempts`)
+					);
+				}
+			}
+		};
+
+		tryConnect();
+
+		return Service.instance<WampClient>(getConnectionName(name), client);
+	};
+
+	/**
+	 * Checks if a WAMP connection with the given name exists.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 * @param name The name of the connection.
+	 * @returns `true` if the connection exists, `false` otherwise.
+	 */
+	export const connectionExists = (name: string) => {
+		return Service.exists(getConnectionName(name));
+	};
+
+	/**
+	 * Retrieves the default WAMP connection.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 * @returns The default WAMP connection.
+	 */
+	export const getDefaultConnection = () => {
+		return getConnection('default');
+	};
+
+	/**
+	 * Sets the default WAMP connection.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 * @param name The name of the connection to set as default.
+	 * @returns The default WAMP connection.
+	 */
+	export const setDefaultConnection = (name: string) => {
+		const serviceName = getConnectionName('default');
+		Service.remove(serviceName);
+		return Service.instance<WampClient>(serviceName, getConnection(name));
+	};
+
 	/**
 	 * Marks a class as a WAMP controller.
 	 * @author Axel Nana <axel.nana@workbud.com>
@@ -213,67 +471,50 @@ export namespace Wamp {
 		return function (target: Class<any>) {
 			async function handleWamp(): Promise<Elysia> {
 				// TODO: Use the logger service here
-				console.log(`Registering Wamp route for ${options.url} using ${target.name}`);
+				console.log(
+					`Registering Wamp controller for connection ${options.connection} using ${target.name}`
+				);
 				await nextTick();
 
 				const controller = Service.make(target);
 
 				const metadata = Reflect.getMetadata(Symbols.wamp, target) ?? {};
 
-				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);
-						// TODO: Add more details like controller name and url
-						Event.emit('elysium:error', new Error('Wamp connection error'));
-					},
-					onReconnect: metadata.reconnect?.bind(controller),
-					onReconnectSuccess: metadata.reconnectSuccess?.bind(controller)
-				});
+				const w = Wamp.getConnection(options.connection ?? 'default');
 
 				const app = new Elysia();
 
 				app.onStart(async (_) => {
-					try {
-						await w.connect();
-						metadata.open?.call(controller);
-
-						const registrations: WampRegistration[] = metadata.registrations ?? [];
-						const subscriptions: WampSubscription[] = metadata.subscriptions ?? [];
-
-						for (const registration of registrations) {
-							w.register(
-								registration.topic,
-								registration.handler.bind(controller),
-								registration.options
-							).then((r: { topic: string; requestId: string; registrationId: string }) => {
+					const registrations: WampRegistration[] = metadata.registrations ?? [];
+					const subscriptions: WampSubscription[] = metadata.subscriptions ?? [];
+
+					for (const registration of registrations) {
+						w.register(
+							registration.topic,
+							registration.handler.bind(controller),
+							registration.options
+						).then((r: { topic: string; requestId: string; registrationId: string }) => {
+							// TODO: Use the logger service here
+							console.log(`Registered ${registration.topic} with id ${r.registrationId}`);
+						});
+					}
+
+					for (const subscription of subscriptions) {
+						w.subscribe(
+							subscription.topic,
+							subscription.handler.bind(controller),
+							subscription.options
+						).then(
+							(s: {
+								topic: string;
+								requestId: string;
+								subscriptionId: string;
+								subscriptionKey: string;
+							}) => {
 								// TODO: Use the logger service here
-								console.log(`Registered ${registration.topic} with id ${r.registrationId}`);
-							});
-						}
-
-						for (const subscription of subscriptions) {
-							w.subscribe(
-								subscription.topic,
-								subscription.handler.bind(controller),
-								subscription.options
-							).then(
-								(s: {
-									topic: string;
-									requestId: string;
-									subscriptionId: string;
-									subscriptionKey: string;
-								}) => {
-									// TODO: Use the logger service here
-									console.log(`Subscribed ${subscription.topic} with id ${s.subscriptionId}`);
-								}
-							);
-						}
-					} catch (error) {
-						// noop
+								console.log(`Subscribed ${subscription.topic} with id ${s.subscriptionId}`);
+							}
+						);
 					}
 				});
 
@@ -325,100 +566,4 @@ export namespace Wamp {
 			Reflect.defineMetadata(Symbols.wamp, metadata, target.constructor);
 		};
 	};
-
-	/**
-	 * 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) {
-			const metadata = Reflect.getMetadata(Symbols.wamp, target.constructor) ?? {};
-			metadata.open = descriptor.value;
-			Reflect.defineMetadata(Symbols.wamp, metadata, target.constructor);
-		};
-	};
-
-	/**
-	 * Marks a method as the WAMP "close" event handler.
-	 *
-	 * 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) {
-			const metadata = Reflect.getMetadata(Symbols.wamp, target.constructor) ?? {};
-			metadata.close = descriptor.value;
-			Reflect.defineMetadata(Symbols.wamp, metadata, target.constructor);
-		};
-	};
-
-	/**
-	 * Marks a method as the WAMP "error" event handler.
-	 *
-	 * 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) {
-			const metadata = Reflect.getMetadata(Symbols.wamp, target.constructor) ?? {};
-			metadata.error = descriptor.value;
-			Reflect.defineMetadata(Symbols.wamp, metadata, target.constructor);
-		};
-	};
-
-	/**
-	 * Marks a method as the WAMP "reconnect" event handler.
-	 *
-	 * 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) {
-			const metadata = Reflect.getMetadata(Symbols.wamp, target.constructor) ?? {};
-			metadata.reconnect = descriptor.value;
-			Reflect.defineMetadata(Symbols.wamp, metadata, target.constructor);
-		};
-	};
-
-	/**
-	 * Marks a method as the WAMP "reconnectSuccess" event handler.
-	 *
-	 * 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) {
-			const metadata = Reflect.getMetadata(Symbols.wamp, target.constructor) ?? {};
-			metadata.reconnectSuccess = descriptor.value;
-			Reflect.defineMetadata(Symbols.wamp, metadata, target.constructor);
-		};
-	};
 }