@elysiumjs/core 0.3.2 → 0.4.1

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;
@@ -103,7 +114,7 @@ const parseTypes = (element: PgColumn) => {
 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.
@@ -136,10 +147,17 @@ export type ModelClass<
 	 */
 	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.
@@ -179,9 +197,12 @@ export const Model = <
 	TColumnsMap extends Record<string, PgColumnBuilderBase>
 >(
 	tableName: TTableName,
-	columns: TColumnsMap
+	columns: TColumnsMap,
+	extraConfig?: (
+		self: BuildExtraConfigColumns<TTableName, TColumnsMap, 'pg'>
+	) => PgTableExtraConfigValue[]
 ) => {
-	const table = pgTable(tableName, columns);
+	const table = pgTable(tableName, columns, extraConfig);
 
 	class M {
 		/**
@@ -227,10 +248,15 @@ export const Model = <
 		 */
 		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.

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,14 +58,14 @@ 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 });
+				const plugin: ElysiaApp = new Elysia({ name: target.name, prefix: options.prefix });
 				plugin.decorate('module', m);
 
 				const middlewares = Reflect.getMetadata(Symbols.middlewares, target) ?? [];
@@ -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/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);
 			}