@stone-js/starters 0.8.3

package/full-service-imperative/app/configurations/AppConfiguration.ts

@@ -0,0 +1,44 @@
+import { Config } from '@libsql/client'
+import { getString } from '@stone-js/env'
+import { CORSHeadersMiddleware } from '@stone-js/http-core'
+import { defineBlueprintMiddleware, defineConfig, IBlueprint, LogLevel, Promiseable } from '@stone-js/core'
+
+/**
+ * User Implicit Configuration
+ *
+ * Explicit configuration takes precedence over implicit configuration.
+ * Implicit configuration are defined at decorators level.
+ */
+export const AppConfiguration = defineConfig((blueprint: IBlueprint): Promiseable<void> => {
+  blueprint
+    .set('database', databaseConfig())
+    .set('security', securityConfig())
+    .set('stone.logger.level', LogLevel.INFO)
+    .set('stone.http.cors.preflightStop', true)
+    .set('stone.http.cors.allowedHeaders', ['*'])
+    .set(defineBlueprintMiddleware(CORSHeadersMiddleware))
+})
+
+/**
+ * Get the database configuration
+ */
+function databaseConfig (): Config {
+  return {
+    url: getString('DATABASE_URL', 'file:local.db')
+  }
+}
+
+/**
+ * Get the security configuration
+ */
+function securityConfig (): Record<string, any> {
+  return {
+    jwt: {
+      expiresIn: 3600
+    },
+    secret: getString('SECURITY_JWT_SECRET', 'non_prod_secret'),
+    bcrypt: {
+      saltRounds: 10
+    }
+  }
+}

package/full-service-imperative/app/configurations/UserLiveConfiguration.ts

@@ -0,0 +1,26 @@
+import { defineConfig, IBlueprint } from '@stone-js/core'
+
+/**
+ * Configure the application
+ *
+ * @param blueprint - The blueprint to configure
+ */
+export async function liveConfig (blueprint: IBlueprint): Promise<void> {
+  blueprint.set('stone.name', await fetchConfigurationRemotely())
+  console.log('I am live cause i am loaded at each request...')
+}
+
+/**
+ * Fetch the configuration remotely
+ */
+async function fetchConfigurationRemotely (): Promise<string> {
+  console.log('Fetching configuration...')
+  return await Promise.resolve('My Fetched app name')
+}
+
+/**
+ * User Live Configuration
+ */
+export const UserLiveConfiguration = defineConfig((blueprint: IBlueprint): void => {
+  blueprint.add('stone.liveConfigurations', [liveConfig])
+})

package/full-service-imperative/app/database/DatabaseClient.ts

@@ -0,0 +1,39 @@
+import { Client, Config, createClient as baseCreateClient } from '@libsql/client'
+
+/**
+ * DatabaseClient
+*/
+let dbClient: Client | undefined
+
+/**
+ * The client instance
+ */
+export function getClient (): Client {
+  if (dbClient === undefined) {
+    throw new Error('Database client is not initialized.')
+  }
+  return dbClient
+}
+
+/**
+ * Create a new client instance
+ *
+ * @param config - The configuration object for the client
+ * @returns The client instance
+ */
+export function createClient (config: Config): Client {
+  if (dbClient === undefined) {
+    dbClient = baseCreateClient(config)
+  }
+  return dbClient
+}
+
+/**
+ * Close the client instance
+ */
+export function closeClient (): void {
+  if (dbClient !== undefined) {
+    dbClient.close()
+    dbClient = undefined
+  }
+}

package/full-service-imperative/app/database/schema.ts

@@ -0,0 +1,43 @@
+import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core'
+
+// User Table
+export const users = sqliteTable('users', {
+  id: integer('id').primaryKey(),
+  name: text('name').notNull(),
+  password: text('password'),
+  avatar: text('avatar'),
+  email: text('email').unique().notNull(),
+  updatedAt: integer('updated_at').notNull(),
+  createdAt: integer('created_at').notNull() // Store timestamps as integers (Unix timestamp)
+})
+
+export const sessions = sqliteTable('sessions', {
+  id: integer('id').primaryKey(),
+  ip: text('ip').notNull(),
+  userAgent: text('user_agent'),
+  closedAt: integer('closed_at'),
+  uuid: text('uuid').unique().notNull(),
+  createdAt: integer('created_at').notNull(),
+  expiresAt: integer('expires_at').notNull(),
+  lastActivityAt: integer('last_activity_at').notNull(),
+  userId: integer('user_id').notNull().references(() => users.id, { onDelete: 'cascade' })
+})
+
+// Post Table
+export const posts = sqliteTable('posts', {
+  id: integer('id').primaryKey(),
+  title: text('title').notNull(),
+  content: text('content').notNull(),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+  authorId: integer('author_id').notNull().references(() => users.id, { onDelete: 'cascade' })
+})
+
+// Comment Table
+export const comments = sqliteTable('comments', {
+  id: integer('id').primaryKey(),
+  content: text('content').notNull(),
+  createdAt: integer('created_at').notNull(),
+  authorId: integer('author_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  postId: integer('post_id').notNull().references(() => posts.id, { onDelete: 'cascade' })
+})

package/full-service-imperative/app/error-handlers/SecurityErrorHandler.ts

@@ -0,0 +1,58 @@
+import { BadCredentialsError } from '../errors/CredentialsError'
+import { defineErrorHandler, FunctionalErrorHandler, ILogger, Promiseable } from '@stone-js/core'
+import { BadRequestError, HTTP_BAD_REQUEST, HTTP_INTERNAL_SERVER_ERROR, HTTP_NOT_FOUND, HTTP_UNAUTHORIZED, IncomingHttpEvent, NotFoundError, UnauthorizedError } from '@stone-js/http-core'
+
+/**
+ * User Error Handler Options
+ */
+export interface SecurityErrorHandlerOptions {
+  logger: ILogger
+}
+
+/**
+ * Factory User Error Handler
+ */
+export function factorySecurityErrorHandler ({ logger }: SecurityErrorHandlerOptions): FunctionalErrorHandler<IncomingHttpEvent> {
+  /**
+   * Handle CredentialsError and UnauthorizedError
+   *
+   * @param error - The error to handle
+   * @param _event - The incoming event
+   * @returns The response
+   */
+  return function (error: BadCredentialsError | UnauthorizedError | NotFoundError | BadRequestError, _event: IncomingHttpEvent): Promiseable<unknown> {
+    logger.error(error.message)
+
+    let message: string = 'An error occurred'
+    let statusCode: number = HTTP_INTERNAL_SERVER_ERROR
+
+    if (error instanceof NotFoundError) {
+      message = error.message
+      statusCode = HTTP_NOT_FOUND
+    } else if (error instanceof BadCredentialsError) {
+      message = 'Invalid credentials'
+      statusCode = HTTP_UNAUTHORIZED
+    } else if (error instanceof UnauthorizedError) {
+      statusCode = HTTP_UNAUTHORIZED
+      message = 'You are not authorized to perform this action'
+    } else if (error instanceof BadRequestError) {
+      statusCode = HTTP_BAD_REQUEST
+      message = error.message
+    }
+
+    return {
+      statusCode,
+      content: {
+        errors: { message }
+      }
+    }
+  }
+}
+
+/**
+ * User Error Handler
+ */
+export const SecurityErrorHandler = defineErrorHandler(
+  factorySecurityErrorHandler,
+  { isFactory: true, error: ['BadCredentialsError', 'UnauthorizedError', 'NotFoundError', 'BadRequestError'] }
+)

package/full-service-imperative/app/errors/CredentialsError.ts

@@ -0,0 +1,12 @@
+import { ErrorOptions } from '@stone-js/core'
+import { UnauthorizedError } from '@stone-js/http-core'
+
+/**
+ * Bad Credentials Error
+ */
+export class BadCredentialsError extends UnauthorizedError {
+  constructor (message: string, options?: ErrorOptions) {
+    super(message, options)
+    this.name = 'BadCredentialsError'
+  }
+}

package/full-service-imperative/app/events/UserEvent.ts

@@ -0,0 +1,17 @@
+import { Event } from '@stone-js/core'
+
+/**
+ * User Event
+ */
+export class UserEvent extends Event {
+  /**
+   * USER_CREATED Event name, fires after a user have been created.
+   *
+   * @event UserEvent#USER_CREATED
+   */
+  static USER_CREATED: string = 'user.created'
+
+  constructor (public readonly user: any) {
+    super({ type: UserEvent.USER_CREATED })
+  }
+}

package/full-service-imperative/app/handlers/CommentEventHandler.ts

@@ -0,0 +1,99 @@
+import { User } from '../models/User'
+import { Post as BlogPost } from '../models/Post'
+import { IncomingHttpEvent } from '@stone-js/http-core'
+import { FunctionalEventHandler, ILogger } from '@stone-js/core'
+import { postResolveRouteBinding } from '../services/PostService'
+import { CommentModel, CommentResponse } from '../models/Comment'
+import { defineRoutes, DELETE, GET, POST } from '@stone-js/router'
+import { ICommentService } from '../services/contracts/ICommentService'
+import { commentResolveRouteBinding } from '../services/CommentService'
+
+/**
+ * Comment Event Handler Options
+ */
+export interface CommentEventHandlerOptions {
+  logger: ILogger
+  commentService: ICommentService
+}
+
+/**
+ * List all comments
+ */
+export function factoryCommentListEventHandler ({ commentService }: CommentEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<CommentResponse[]> {
+    return await commentService.list(event.get<number>('limit', 10))
+  }
+}
+
+/**
+ * List comments by post
+ */
+export function factoryCommentListByPostEventHandler ({ commentService }: CommentEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<CommentResponse[]> {
+    return await commentService.listByPost(
+      event.get<number>('postId', 0),
+      event.get<number>('limit', 10)
+    )
+  }
+}
+
+/**
+ * List comments by author
+ */
+export function factoryCommentListByAuthorEventHandler ({ commentService }: CommentEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<CommentResponse[]> {
+    return await commentService.listByAuthor(
+      event.get<number>('authorId', 0),
+      event.get<number>('limit', 10)
+    )
+  }
+}
+
+/**
+ * Show a comment by ID
+ */
+export function factoryCommentShowEventHandler ({ commentService }: CommentEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return function (event: IncomingHttpEvent): CommentResponse {
+    return event.get<CommentResponse>('comment', {} as unknown as CommentResponse)
+  }
+}
+
+/**
+ * Create a comment
+ */
+export function factoryCommentCreateEventHandler ({ commentService }: CommentEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<{ id?: number }> {
+    const id = await commentService.create({
+      ...event.getBody<CommentModel>({} as any),
+      authorId: event.getUser<User>()?.id ?? 0,
+      postId: event.get<BlogPost>('post', { id: 0 } as any).id
+    })
+
+    return { id: Number(id) }
+  }
+}
+
+/**
+ * Delete a comment
+ */
+export function factoryCommentDeleteEventHandler ({ commentService, logger }: CommentEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<{ statusCode: number }> {
+    await commentService.delete(event.get<number>('id', 0))
+    logger.info(`Comment deleted: ${String(event.get<number>('id'))}, by user: ${String(event.getUser<User>()?.id)}`)
+    return { statusCode: 204 }
+  }
+}
+
+/**
+ * Comment Event Handler
+*/
+export const CommentEventHandler = defineRoutes(
+  [
+    [factoryCommentListEventHandler, { isFactory: true, path: '/comments/', method: GET, name: 'comments.list' }],
+    [factoryCommentDeleteEventHandler, { isFactory: true, path: '/comments/:id', method: DELETE, name: 'comments.delete', rules: { id: /\d+/ } }],
+    [factoryCommentListByPostEventHandler, { isFactory: true, path: '/comments/posts/:postId(\\d+)', method: GET, name: 'comments.list-by-post' }],
+    [factoryCommentListByAuthorEventHandler, { isFactory: true, path: '/comments/authors/:authorId(\\d+)', method: GET, name: 'comments.list-by-author' }],
+    [factoryCommentShowEventHandler, { isFactory: true, path: '/comments/:comment@id(\\d+)', method: GET, name: 'comments.show', bindings: { user: commentResolveRouteBinding } }],
+    [factoryCommentCreateEventHandler, { isFactory: true, path: '/comments/posts/:post@id(\\d+)', method: POST, name: 'comments.create', bindings: { post: postResolveRouteBinding } }]
+  ]
+)

package/full-service-imperative/app/handlers/PostEventHandler.ts

@@ -0,0 +1,99 @@
+import { User } from '../models/User'
+import { PostModel, PostResponse } from '../models/Post'
+import { FunctionalEventHandler, ILogger } from '@stone-js/core'
+import { IPostService } from '../services/contracts/IPostService'
+import { postResolveRouteBinding } from '../services/PostService'
+import { defineRoutes, DELETE, GET, PATCH, POST } from '@stone-js/router'
+import { IncomingHttpEvent, InternalServerError } from '@stone-js/http-core'
+
+/**
+ * Post Event Handler Options
+ */
+export interface PostEventHandlerOptions {
+  logger: ILogger
+  postService: IPostService
+}
+
+/**
+ * List all posts
+ */
+export function factoryPostListEventHandler ({ postService }: PostEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<PostResponse[]> {
+    return await postService.list(event.get<number>('limit', 10))
+  }
+}
+
+/**
+ * List all posts by a specific author
+ */
+export function factoryPostListByAuthorEventHandler ({ postService }: PostEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<PostResponse[]> {
+    return await postService.listByAuthor(
+      event.get<number>('id', 0),
+      event.get<number>('limit', 10)
+    )
+  }
+}
+
+/**
+ * Show a post by ID
+ */
+export function factoryPostShowEventHandler (): FunctionalEventHandler<IncomingHttpEvent> {
+  return function (event: IncomingHttpEvent): PostResponse {
+    return event.get<PostResponse>('post', {} as unknown as PostResponse)
+  }
+}
+
+/**
+ * Create a post
+ */
+export function factoryPostCreateEventHandler ({ postService }: PostEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<{ id?: number }> {
+    const id = await postService.create({
+      ...event.getBody<PostModel>({} as any),
+      authorId: event.getUser<User>()?.id ?? 0
+    })
+
+    return { id: Number(id) }
+  }
+}
+
+/**
+ * Update a post
+ */
+export function factoryPostUpdateEventHandler ({ postService }: PostEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<void> {
+    const updated = await postService.update(event.get<number>('id', 0), event.getBody<PostModel>({} as any))
+    if (!updated) {
+      throw new InternalServerError(`Failed to update post with ID ${String(event.get<number>('id'))}`)
+    }
+  }
+}
+
+/**
+ * Delete a post
+ */
+export function factoryPostDeleteEventHandler ({ postService, logger }: PostEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<{ statusCode: number }> {
+    const deleted = await postService.delete(event.get<number>('id', 0))
+    if (!deleted) {
+      throw new InternalServerError(`Failed to update post with ID ${String(event.get<number>('id'))}`)
+    }
+    logger.info(`Post deleted: ${String(event.get<number>('id'))}, by user: ${String(event.getUser<User>()?.id)}`)
+    return { statusCode: 204 }
+  }
+}
+
+/**
+ * Post Event Handler
+*/
+export const PostEventHandler = defineRoutes(
+  [
+    [factoryPostListEventHandler, { isFactory: true, path: '/posts/', method: GET, name: 'posts.list' }],
+    [factoryPostCreateEventHandler, { isFactory: true, path: '/posts/', method: POST, name: 'posts.create' }],
+    [factoryPostUpdateEventHandler, { isFactory: true, path: '/posts/:id', method: PATCH, name: 'posts.update', rules: { id: /\d+/ } }],
+    [factoryPostDeleteEventHandler, { isFactory: true, path: '/posts/:id', method: DELETE, name: 'posts.delete', rules: { id: /\d+/ } }],
+    [factoryPostListByAuthorEventHandler, { isFactory: true, path: '/posts/authors/:authorId(\\d+)', method: GET, name: 'posts.list-by-author' }],
+    [factoryPostShowEventHandler, { isFactory: true, path: '/posts/:post@id(\\d+)', method: GET, name: 'posts.show', bindings: { user: postResolveRouteBinding } }]
+  ]
+)

package/full-service-imperative/app/handlers/SecurityEventHandler.ts

@@ -0,0 +1,83 @@
+import { defineRoutes, POST } from '@stone-js/router'
+import { IncomingHttpEvent } from '@stone-js/http-core'
+import { FunctionalEventHandler, ILogger } from '@stone-js/core'
+import { ISecurityService } from '../services/contracts/ISecurityService'
+import { UserChangePassword, UserLogin, UserRegister, UserToken } from '../models/User'
+
+/**
+ * Security Event Handler Options
+*/
+export interface SecurityEventHandlerOptions {
+  logger: ILogger
+  securityService: ISecurityService
+}
+
+/**
+ * Login a user
+*/
+export function factoryLoginEventHandler ({ securityService }: SecurityEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<UserToken> {
+    return await securityService.login(
+      event,
+      event.getBody<UserLogin>({ email: '', password: '' })
+    )
+  }
+}
+
+/**
+ * Logout a user
+*/
+export function factoryLogoutEventHandler ({ securityService }: SecurityEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<void> {
+    await securityService.logout(
+      event.get<string>('Authorization', '').replace('Bearer ', '')
+    )
+  }
+}
+
+/**
+ * Refresh a token
+*/
+export function factoryRefreshEventHandler ({ securityService }: SecurityEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<UserToken> {
+    return await securityService.refresh(
+      event.get<string>('Authorization', '').replace('Bearer ', '')
+    )
+  }
+}
+
+/**
+ * Register a user
+*/
+export function factoryRegisterEventHandler ({ securityService }: SecurityEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<void> {
+    await securityService.register(
+      event.getBody<UserRegister>({} as any)
+    )
+  }
+}
+
+/**
+ * Change password
+*/
+export function factoryChangePasswordEventHandler ({ securityService }: SecurityEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<void> {
+    await securityService.changePassword(
+      event.getUser(),
+      event.getBody<UserChangePassword>()
+    )
+  }
+}
+
+/**
+ * Security Event Handler
+*/
+export const SecurityEventHandler = defineRoutes(
+  [
+    [factoryLoginEventHandler, { isFactory: true, path: '/login', method: POST, name: 'login' }],
+    [factoryLogoutEventHandler, { isFactory: true, path: '/logout', method: POST, name: 'logout' }],
+    [factoryRefreshEventHandler, { isFactory: true, path: '/refresh', method: POST, name: 'refresh' }],
+    [factoryRegisterEventHandler, { isFactory: true, path: '/register', method: POST, name: 'register' }],
+    [factoryChangePasswordEventHandler, { isFactory: true, path: '/change-password', method: POST, name: 'change-password' }]
+  ]
+)

package/full-service-imperative/app/handlers/UserEventHandler.ts

@@ -0,0 +1,132 @@
+import { File } from '@stone-js/filesystem'
+import { IncomingHttpEvent } from '@stone-js/http-core'
+import { User, UserModel, UserResponse } from '../models/User'
+import { FunctionalEventHandler, ILogger } from '@stone-js/core'
+import { IUserService } from '../services/contracts/IUserService'
+import { userResolveRouteBinding } from '../services/UserService'
+import { defineRoutes, DELETE, GET, PATCH, POST } from '@stone-js/router'
+
+/**
+ * User Event Handler Options
+*/
+export interface UserEventHandlerOptions {
+  logger: ILogger
+  userService: IUserService
+}
+
+/**
+ * List all users
+*/
+export function factoryUserListEventHandler ({ userService }: UserEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<UserResponse[]> {
+    return await userService.list(event.get<number>('limit', 10))
+  }
+}
+
+/**
+ * Show current user
+*/
+export function factoryUserShowCurrentEventHandler (): FunctionalEventHandler<IncomingHttpEvent> {
+  return function (event: IncomingHttpEvent): UserResponse {
+    const user = { ...event.getUser<UserModel>(), password: undefined }
+    return user as UserResponse
+  }
+}
+
+/**
+ * Show a user
+*/
+export function factoryUserShowEventHandler (): FunctionalEventHandler<IncomingHttpEvent> {
+  return function (event: IncomingHttpEvent): UserResponse {
+    return event.get<UserResponse>('user', {} as unknown as UserResponse)
+  }
+}
+
+/**
+ * Show a user avatar
+ */
+export function factoryUserAvatarEventHandler (): FunctionalEventHandler<IncomingHttpEvent> {
+  return function (event: IncomingHttpEvent): File {
+    const user = event.get<UserResponse>('user', {} as unknown as UserResponse)
+    return File.create(`public/uploads/${String(user.avatar)}`)
+  }
+}
+
+/**
+ * Create a user
+*/
+export function factoryUserCreateEventHandler ({ userService }: UserEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<{ id?: number }> {
+    const id = await userService.create(handleFileUpload(event))
+    return { id: Number(id) }
+  }
+}
+
+/**
+ * Update the current user
+*/
+export function factoryUserUpdateCurrentEventHandler ({ userService }: UserEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<UserResponse> {
+    return await userService.update(
+      event.getUser<UserModel>()?.id ?? 0,
+      handleFileUpload(event)
+    )
+  }
+}
+
+/**
+ * Update a user
+*/
+export function factoryUserUpdateEventHandler ({ userService }: UserEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<UserResponse> {
+    return await userService.update(
+      event.get<number>('id', 0),
+      handleFileUpload(event)
+    )
+  }
+}
+
+/**
+ * Delete a user
+*/
+export function factoryUserDeleteEventHandler ({ logger, userService }: UserEventHandlerOptions): FunctionalEventHandler<IncomingHttpEvent> {
+  return async function (event: IncomingHttpEvent): Promise<{ statusCode: number }> {
+    await userService.delete(event.get<number>('id', 0))
+    logger.info(`User deleted: ${String(event.get<number>('id'))}, by user: ${String(event.getUser<User>()?.id)}`)
+    return { statusCode: 204 }
+  }
+}
+
+/**
+ * Handle file upload
+ *
+ * @param event - IncomingHttpEvent
+ * @param payload - UserModel
+*/
+function handleFileUpload (event: IncomingHttpEvent): UserModel {
+  const payload = event.getBody<UserModel>({} as any)
+
+  if (event.hasFile('avatar')) {
+    const file = event.getFile('avatar')?.[0]
+    payload.avatar = `${crypto.randomUUID()}-${String(file?.getClientOriginalName())}`
+    file?.move('public/uploads', payload.avatar)
+  }
+
+  return payload
+}
+
+/**
+ * User Event Handler
+*/
+export const UserEventHandler = defineRoutes(
+  [
+    [factoryUserListEventHandler, { isFactory: true, path: '/users/', method: GET, name: 'users.list' }],
+    [factoryUserCreateEventHandler, { isFactory: true, path: '/users/', method: POST, name: 'users.create' }],
+    [factoryUserDeleteEventHandler, { isFactory: true, path: '/users/:id', method: DELETE, name: 'users.delete' }],
+    [factoryUserShowCurrentEventHandler, { isFactory: true, path: '/users/me', method: GET, name: 'users.show-current' }],
+    [factoryUserUpdateCurrentEventHandler, { isFactory: true, path: '/users/me', method: PATCH, name: 'users.update-current' }],
+    [factoryUserUpdateEventHandler, { isFactory: true, path: '/users/:id', method: PATCH, name: 'users.update', rules: { id: /\d+/ } }],
+    [factoryUserShowEventHandler, { isFactory: true, path: '/users/:user@id(\\d+)', method: GET, name: 'users.show', bindings: { user: userResolveRouteBinding } }],
+    [factoryUserAvatarEventHandler, { isFactory: true, path: '/users/:user@id(\\d+)/avatar', method: GET, name: 'users.avatar', bindings: { user: userResolveRouteBinding } }]
+  ]
+)

package/full-service-imperative/app/listeners/UserEventListener.ts

@@ -0,0 +1,23 @@
+import { UserEvent } from '../events/UserEvent'
+import { defineEventListener, FunctionalEventListener, ILogger } from '@stone-js/core'
+
+/**
+ * User Event Listener Options
+*/
+export interface UserEventListenerOptions {
+  logger: ILogger
+}
+
+/**
+ * Factory User event listener
+ */
+export function fatoryUserEventListener ({ logger }: UserEventListenerOptions): FunctionalEventListener<UserEvent> {
+  return function (event: UserEvent): void {
+    logger.info('User event listener', event)
+  }
+}
+
+/**
+ * User event listener Type
+ */
+export const UserEventListener = defineEventListener(fatoryUserEventListener, { isFactory: true, event: UserEvent.USER_CREATED })