@elysiumjs/core 0.1.1 → 0.3.0

package/index.ts

@@ -12,7 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-export { type AppContext, Application } from './src/app';
+import './macros';
+
+export { type Elysia, t } from 'elysia';
+export { type AppContext, type ElysiumPlugin, Application } from './src/app';
 export { Cache } from './src/cache';
 export {
 	type CommandArgumentProps,
@@ -22,6 +25,7 @@ export {
 } from './src/command';
 export { ConsoleFormat, InteractsWithConsole } from './src/console';
 export { Database } from './src/database';
+export { Env } from './src/env';
 export { type EventData, type EventHandler, Event } from './src/event';
 export { type Context, type Route, HttpControllerScope, Http } from './src/http';
 export { Job } from './src/job';

package/macros.ts

@@ -0,0 +1,16 @@
+// 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.
+
+// Disable build mode by default
+global.ELYSIUM_BUILD = typeof ELYSIUM_BUILD !== 'undefined';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@elysiumjs/core",
-	"version": "0.1.1",
+	"version": "0.3.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.42.0",
+		"drizzle-orm": "^0.43.1",
 		"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.0",
+		"type-fest": "^4.40.1",
 		"@types/bun": "latest"
 	},
 	"peerDependencies": {

package/src/app.ts

@@ -13,10 +13,10 @@
 // limitations under the License.
 
 import type { ElysiaSwaggerConfig } from '@elysiajs/swagger';
-import type { ElysiaConfig, ErrorContext, PreContext } from 'elysia';
+import type { AnyElysia, ElysiaConfig, ErrorContext, TSchema } from 'elysia';
 import type { CommandClass } from './command';
 import type { DatabaseConnectionProps } from './database';
-import type { Route, Singleton } from './http';
+import type { Route } from './http';
 import type { ModuleClass } from './module';
 import type { RedisConnectionProps } from './redis';
 
@@ -24,16 +24,23 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { parseArgs } from 'node:util';
 
 import { swagger as swaggerPlugin } from '@elysiajs/swagger';
+import { Value } from '@sinclair/typebox/value';
 import { Elysia } from 'elysia';
-import { assign } from 'radash';
 
 import { ConsoleFormat, InteractsWithConsole } from './console';
 import { Database } from './database';
+import { initEnv } from './env';
 import { Event } from './event';
 import { applyMiddlewares } from './middleware';
 import { Redis } from './redis';
 import { Service } from './service';
-import { Symbols } from './utils';
+import { deepMerge, Symbols } from './utils';
+
+/**
+ * An application plugin, consisting of a function that returns an Elysia instance.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ElysiumPlugin = (app: Application) => Promise<AnyElysia>;
 
 /**
  * Properties required when declaring an app using the `@app()` decorator.
@@ -101,6 +108,16 @@ export type AppProps = {
 	 * Set it to `false` to disable Swagger documentation.
 	 */
 	swagger?: ElysiaSwaggerConfig<Route> | false;
+
+	/**
+	 * The validation schema for the application environment.
+	 */
+	env?: TSchema;
+
+	/**
+	 * The list of plugins to load.
+	 */
+	plugins?: ElysiumPlugin[];
 };
 
 /**
@@ -140,8 +157,35 @@ export abstract class Application extends InteractsWithConsole {
 	 */
 	public static register(props: AppProps = {}): ClassDecorator {
 		return function (target) {
-			props = assign<AppProps>({ modules: [], database: undefined, swagger: false }, props);
-			props = assign<AppProps>(Reflect.getMetadata(Symbols.app, target) ?? {}, props);
+			// Get metadata from the prototype chain
+			let parentMetadata: AppProps | undefined;
+			let proto = Object.getPrototypeOf(target);
+
+			// Traverse up the prototype chain to find metadata
+			while (proto && proto !== Object.prototype) {
+				const metadata = Reflect.getMetadata(Symbols.app, proto);
+				if (metadata) {
+					parentMetadata = metadata;
+					break;
+				}
+				proto = Object.getPrototypeOf(proto);
+			}
+
+			// Merge with parent metadata if found, then with current metadata
+			if (parentMetadata) {
+				props = deepMerge<AppProps>(parentMetadata, props);
+			}
+
+			// Merge with existing metadata on the current class (if any)
+			const currentMetadata = Reflect.getMetadata(Symbols.app, target);
+			if (currentMetadata) {
+				props = deepMerge<AppProps>(currentMetadata, props);
+			}
+
+			// Default props
+			props = deepMerge<AppProps>({ modules: [], swagger: false }, props);
+
+			// Store the merged metadata
 			Reflect.defineMetadata(Symbols.app, props, target);
 		};
 	}
@@ -152,14 +196,25 @@ export abstract class Application extends InteractsWithConsole {
 	public constructor() {
 		super();
 
-		Service.instance('elysium.app', this);
+		const { env, debug }: AppProps = Reflect.getMetadata(Symbols.app, this.constructor) ?? {};
+		this.#debug = debug ?? false;
 
-		const { debug, database, redis } = Reflect.getMetadata(
-			Symbols.app,
-			this.constructor
-		) as AppProps;
+		if (env) {
+			const rawEnv = Value.Convert(env, Value.Clone(Bun.env));
 
-		this.#debug = debug ?? false;
+			if (this.#debug && !Value.Check(env, rawEnv)) {
+				const error = Value.Errors(env, rawEnv).First();
+				this.trace(error! as unknown as Error, 'Invalid environment configuration');
+			}
+
+			initEnv(Value.Clean(env, rawEnv) as Record<string, unknown>);
+		} else {
+			initEnv(Bun.env);
+		}
+
+		Service.instance('elysium.app', this);
+
+		const { database, redis } = Reflect.getMetadata(Symbols.app, this.constructor) as AppProps;
 
 		if (redis) {
 			for (const connectionName in redis.connections) {
@@ -182,7 +237,13 @@ export abstract class Application extends InteractsWithConsole {
 		}
 
 		// Run the application
-		this.run().then(() => Event.emit('elysium:app:launched', this, this));
+		this.run()
+			.then(() => Event.emit('elysium:app:launched', this, this))
+			.catch((error) => {
+				Event.emit('elysium:error', error);
+				this.trace(error, 'An error occurred while launching the application');
+				process.exit(1);
+			});
 	}
 
 	/**
@@ -386,27 +447,114 @@ export abstract class Application extends InteractsWithConsole {
 	 * Starts the server on the specified port.
 	 */
 	private async commandServe(): Promise<void> {
-		const { server, modules, swagger } = Reflect.getMetadata(
+		const { server, modules, swagger, plugins } = Reflect.getMetadata(
 			Symbols.app,
 			this.constructor
 		) as AppProps;
 
+		this.#elysia = new Elysia(server).onRequest((c) => {
+			if (this.isDebug) {
+				// TODO: Use the logger service here
+				console.log(c.request.method, c.request.url);
+			}
+		});
+
 		Event.emit('elysium:server:before-init', this, this);
 
-		this.#elysia = new Elysia(server);
+		this.#elysia.resolve({ as: 'global' }, ({ request }) => ({
+			tenant: request.headers.get('x-tenant-id') ?? 'public'
+		}));
 
-		this.#elysia
-			.onRequest((c: PreContext<Singleton>) => {
-				c.tenant = c.request.headers.get('x-tenant-id') ?? 'public';
+		if (swagger) {
+			this.#elysia.use(await swaggerPlugin(swagger));
+		}
 
-				if (this.isDebug) {
-					// TODO: Use the logger service here
-					console.log(c.request.method, c.request.url);
-				}
-			})
-			.onError(async (e) => {
+		if (plugins && plugins.length > 0) {
+			this.debug('Registering plugins...');
+			for (const plugin of plugins) {
+				this.#elysia.use(await plugin(this));
+			}
+		}
+
+		this.#elysia
+			.onError({ as: 'global' }, async (e) => {
 				if (await this.onError(e)) {
 					Event.emit('elysium:error', e);
+
+					let data = {};
+
+					if (typeof e.code === 'number') {
+						data = {
+							message: e.error.response
+						};
+					} else {
+						switch (e.code) {
+							case 'VALIDATION': {
+								data = {
+									scope: e.error.type,
+									code: e.error.message
+								};
+								break;
+							}
+							case 'INTERNAL_SERVER_ERROR': {
+								data = {
+									message: e.error.message
+								};
+								break;
+							}
+						}
+					}
+
+					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,
+						data
+					};
 				}
 			})
 			.onStart(async (elysia) => {
@@ -419,12 +567,6 @@ export abstract class Application extends InteractsWithConsole {
 				this._appContextStorage.disable();
 			});
 
-		Event.emit('elysium:server:after-init', this, this);
-
-		if (swagger) {
-			this.#elysia.use(await swaggerPlugin(swagger));
-		}
-
 		const middlewares = Reflect.getMetadata(Symbols.middlewares, this.constructor) ?? [];
 		applyMiddlewares(middlewares, this.#elysia);
 
@@ -445,12 +587,13 @@ export abstract class Application extends InteractsWithConsole {
 			module.afterRegister();
 		}
 
+		Event.emit('elysium:server:after-init', this, this);
+
 		// Register the server
 		this.#elysia.listen(server?.port ?? (parseInt(process.env.PORT!, 10) || 3000));
 
 		process.on('SIGINT', () => {
-			this.#elysia.stop();
-			return process.exit(0);
+			this.#elysia.stop().then(() => process.exit(0));
 		});
 	}
 

package/src/console.ts

@@ -166,7 +166,7 @@ export class InteractsWithConsole {
 			this.write(this.format('Additional Information:', ConsoleFormat.BOLD));
 			Object.keys(customProps).forEach((prop) => {
 				const value = error[prop];
-				this.write(`\t${prop}: ${JSON.stringify(value)}`, false);
+				this.write(`\t${prop}: ${JSON.stringify(value)}`);
 			});
 		}
 	}

package/src/env.ts

@@ -0,0 +1,58 @@
+// 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 { AppEnv } from '@elysiumjs/core';
+
+const env: Map<string, unknown> = new Map();
+
+/**
+ * Initializes the environment variables.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param vars The environment variables to initialize.
+ */
+export const initEnv = (vars: Record<string, unknown>) => {
+	for (const [key, value] of Object.entries(vars)) {
+		env.set(key, value);
+	}
+};
+
+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.
+	 * @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];
+	};
+
+	/**
+	 * Checks if an environment variable exists.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 * @param name The name of the environment variable.
+	 * @returns `true` if the environment variable exists, `false` otherwise.
+	 */
+	export const exists = <TKey extends keyof AppEnv>(name: TKey): boolean => {
+		return env.has(name);
+	};
+
+	/**
+	 * Clears the environment variables.
+	 * @author Axel Nana <axel.nana@workbud.com>
+	 */
+	export const clear = () => {
+		env.clear();
+	};
+}

package/src/http.ts

@@ -12,15 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import type {
-	Context as ElysiaContext,
-	Handler,
-	HTTPMethod,
-	PreContext,
-	SingletonBase,
-	TSchema
-} from 'elysia';
-import type { Class } from 'type-fest';
+import type { AppHttpContext } from '@elysiumjs/core';
+import type { Context as ElysiaContext, Handler, HTTPMethod, PreContext, TSchema } from 'elysia';
+import type { Class, MergeDeep } from 'type-fest';
 import type { Middleware } from './middleware';
 import type { Module } from './module';
 
@@ -140,22 +134,31 @@ type HttpRequestHandlerRegistrationProps = Pick<
  * Metadata for the HTTP context.
  * @author Axel Nana <axel.nana@workbud.com>
  */
-export type Singleton<TController = unknown, TModule extends Module = Module> = SingletonBase & {
-	/**
-	 * The controller instance.
-	 */
-	controller: TController;
-
-	/**
-	 * The module instance.
-	 */
-	module: TModule;
+export type Singleton<TController = unknown, TModule extends Module = Module> = MergeDeep<
+	AppHttpContext,
+	{
+		decorator: {
+			[key: string]: unknown;
+
+			/**
+			 * The controller instance.
+			 */
+			controller: () => TController;
+
+			/**
+			 * The module instance.
+			 */
+			module: TModule;
+		};
 
-	/**
-	 * The tenant ID.
-	 */
-	tenant: string;
-};
+		resolve: {
+			/**
+			 * The tenant ID.
+			 */
+			readonly tenant: string;
+		};
+	}
+>;
 
 /**
  * The Elysia context with the controller injected.
@@ -166,6 +169,8 @@ export type Context<TController = unknown, TModule extends Module = Module> = El
 	Singleton<TController, TModule>
 >;
 
+export type ElysiaApp = Elysia<Route, Singleton>;
+
 const registerHttpRequestHandler = (props: HttpRequestHandlerRegistrationProps) => {
 	const body = Reflect.getMetadata('http:body', props.target, props.propertyKey);
 	const params = Reflect.getMetadata('http:params', props.target, props.propertyKey) ?? [];
@@ -295,32 +300,30 @@ export namespace Http {
 	 */
 	export const controller = (props: HttpControllerProps = { path: '/' }) => {
 		return function (target: Class<any>) {
-			async function handleHttp(): Promise<Elysia<Route>> {
+			async function handleHttp(): Promise<ElysiaApp> {
 				// TODO: Use the logger service here
 				console.log(`Registering HTTP route for ${props.path} using ${target.name}`);
 				await nextTick();
 
 				props = assign({ path: '/', scope: HttpControllerScope.SERVER, tags: [] }, props);
 
-				const app = new Elysia({
+				const app: ElysiaApp = new Elysia({
 					prefix: props.path,
 					name: target.name
 				});
 
 				if (props.scope === HttpControllerScope.SERVER) {
-					app.decorate('controller', Service.make(target));
+					const controller = Service.make(target);
+					app.decorate('controller', () => controller);
 				} else if (props.scope === HttpControllerScope.REQUEST) {
-					app.resolve({ as: 'scoped' }, () => ({
-						controller: Service.make(target)
-					}));
+					app.decorate('controller', () => Service.make(target));
 				}
 
 				const onRequest = Reflect.getMetadata('http:onRequest', target) ?? {};
 				if (onRequest.handler) {
-					app.onRequest((c: PreContext<SingletonBase & { controller: any }>) => {
-						const controller = c.controller;
-						const handler = onRequest.handler.bind(controller);
-						return handler(c);
+					app.onRequest((c: PreContext<Singleton>) => {
+						const controller = c.controller();
+						return onRequest.handler.call(controller, c);
 					});
 				}
 
@@ -375,20 +378,18 @@ export namespace Http {
 
 					const getHandler = () => {
 						const initTransactedHandler = (c: Context) => {
-							const controller = c.controller;
-
 							if (isTransactional) {
 								return function (...args: unknown[]) {
 									return Database.getDefaultConnection().transaction((tx) => {
 										return Application.context.run(
 											new Map([
-												['tenant', c.tenant],
+												['tenant', c.tenant as unknown],
 												['http:context', c],
 												['db:tx', tx]
 											]),
 											() => {
 												try {
-													return route.handler.call(controller, ...args) as Promise<unknown>;
+													return route.handler.call(c.controller(), ...args) as Promise<unknown>;
 												} catch (e) {
 													tx.rollback();
 													throw e;
@@ -402,10 +403,10 @@ export namespace Http {
 							return function (...args: unknown[]) {
 								return Application.context.run(
 									new Map([
-										['tenant', c.tenant],
+										['tenant', c.tenant as unknown],
 										['http:context', c]
 									]),
-									() => route.handler.call(controller, ...args) as Promise<unknown>
+									() => route.handler.call(c.controller(), ...args) as Promise<unknown>
 								);
 							};
 						};
@@ -455,13 +456,13 @@ export namespace Http {
 					app.route(route.method, route.path, getHandler(), {
 						// @ts-ignore
 						config: {},
-						beforeHandle(c: Context) {
+						beforeHandle(c) {
 							return executeMiddlewareChain(mi, c, 'onBeforeHandle');
 						},
-						afterHandle(c: Context) {
+						afterHandle(c) {
 							return executeMiddlewareChain(mi, c, 'onAfterHandle');
 						},
-						afterResponse(c: Context) {
+						afterResponse(c) {
 							return executeMiddlewareChain(mi, c, 'onAfterResponse');
 						},
 						detail: {

package/src/middleware.ts

@@ -12,9 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import type { Elysia } from 'elysia';
+import type { AnyElysia } from 'elysia';
 import type { Class } from 'type-fest';
-import type { Context, Route } from './http';
+import type { Context } from './http';
 
 import { Application } from './app';
 import { Service } from './service';
@@ -27,9 +27,9 @@ import { Symbols } from './utils';
  * @param context The context to pass to each middleware.
  * @param method The method to call on each middleware.
  */
-export const executeMiddlewareChain = <T extends Context>(
+export const executeMiddlewareChain = (
 	middlewares: Middleware[],
-	context: T,
+	context: any,
 	method: keyof Middleware
 ): Promise<any> => {
 	return Application.context.run(
@@ -58,7 +58,7 @@ export const executeMiddlewareChain = <T extends Context>(
  * @param middlewares The list of middlewares to apply.
  * @param plugin The Elysia plugin instance.
  */
-export const applyMiddlewares = (middlewares: Class<Middleware>[], plugin: Elysia<Route>) => {
+export const applyMiddlewares = (middlewares: Class<Middleware>[], plugin: AnyElysia) => {
 	const mi = middlewares.map((middleware) => Service.make<Middleware>(middleware));
 
 	plugin.onBeforeHandle((c) => {

package/src/model.ts

@@ -119,6 +119,12 @@ export type ModelClass<
 	 */
 	readonly $inferUpdate: Partial<TTable['$inferSelect']>;
 
+	/**
+	 * The drizzle's table schema wrapped by this model.
+	 * Will be automatically wrapped by the `Tenancy.withTenant()` function when the current tenant is not `public`.
+	 */
+	readonly table: TTable;
+
 	/**
 	 * The name of the table wrapped by the model.
 	 */
@@ -189,6 +195,24 @@ export const Model = <TColumnsMap extends Record<string, PgColumnBuilderBase>>(
 		 */
 		public static readonly $inferUpdate: Partial<typeof table.$inferInsert> = table.$inferInsert;
 
+		/**
+		 * The drizzle's table schema wrapped by this model.
+		 */
+		public static get table(): ReturnType<typeof pgTable<string, TColumnsMap>> {
+			// If we are not inside an Application context, we can't use the tenancy system
+			if (!Application.instance || !Application.context.getStore) {
+				return table;
+			}
+
+			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 table;
+		}
+
 		/**
 		 * The name of the table wrapped by the model.
 		 */
@@ -278,21 +302,21 @@ export namespace Tenancy {
 	>(
 		tenant: string,
 		model: T
-	) => {
+	): ReturnType<typeof pgTable<string, TColumnsMap>> => {
 		if (tenant === 'public') {
 			return pgTable(model.tableName, model.columns);
 		}
 
 		const tableName = `${tenant}.${model.tableName}`;
 		if (tenantSchemas.has(tableName)) {
-			return tenantSchemas.get(tableName)!;
+			return tenantSchemas.get(tableName)! as ReturnType<typeof pgTable<string, TColumnsMap>>;
 		}
 
 		const tenantSchema = getTenantSchema(tenant);
 		const schemaTable = tenantSchema.table(model.tableName, model.columns);
 		tenantSchemas.set(tableName, schemaTable);
 
-		return schemaTable;
+		return schemaTable as unknown as ReturnType<typeof pgTable<string, TColumnsMap>>;
 	};
 
 	/**