@stone-js/starters 0.8.3

package/full-service-declarative/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-declarative/app/handlers/CommentEventHandler.ts

@@ -0,0 +1,103 @@
+import { User } from '../models/User'
+import { ILogger } from '@stone-js/core'
+import { Post as BlogPost } from '../models/Post'
+import { PostService } from '../services/PostService'
+import { CommentService } from '../services/CommentService'
+import { CommentModel, CommentResponse } from '../models/Comment'
+import { Delete, EventHandler, Get, Post } from '@stone-js/router'
+import { IncomingHttpEvent, JsonHttpResponse } from '@stone-js/http-core'
+
+/**
+ * Comment Event Handler Options
+ */
+export interface CommentEventHandlerOptions {
+  logger: ILogger
+  commentService: CommentService
+}
+
+/**
+ * Comment Event Handler
+ *
+ * Handles comment-related HTTP events.
+ */
+@EventHandler('/comments', { name: 'comments' })
+export class CommentEventHandler {
+  private readonly logger: ILogger
+  private readonly commentService: CommentService
+
+  /**
+   * Create a new instance of CommentEventHandler
+   *
+   * @param commentService
+   * @param logger
+   */
+  constructor ({ commentService, logger }: CommentEventHandlerOptions) {
+    this.logger = logger
+    this.commentService = commentService
+  }
+
+  /**
+   * List all comments
+   */
+  @Get('/', { name: 'list' })
+  @JsonHttpResponse(200)
+  async list (event: IncomingHttpEvent): Promise<CommentResponse[]> {
+    return await this.commentService.list(event.get<number>('limit', 10))
+  }
+
+  /**
+   * List comments by post
+   */
+  @Get('/posts/:postId(\\d+)')
+  @JsonHttpResponse(200)
+  async listByPost (event: IncomingHttpEvent): Promise<CommentResponse[]> {
+    return await this.commentService.listByPost(
+      event.get<number>('postId', 0),
+      event.get<number>('limit', 10)
+    )
+  }
+
+  /**
+   * List comments by author
+   */
+  @Get('/authors/:authorId(\\d+)')
+  @JsonHttpResponse(200)
+  async listByAuthor (event: IncomingHttpEvent): Promise<CommentResponse[]> {
+    return await this.commentService.listByAuthor(
+      event.get<number>('authorId', 0),
+      event.get<number>('limit', 10)
+    )
+  }
+
+  /**
+   * Show a comment by ID
+   */
+  @Get('/:comment@id(\\d+)', { bindings: { comment: CommentService } })
+  show (event: IncomingHttpEvent): CommentResponse {
+    return event.get<CommentResponse>('comment', {} as unknown as CommentResponse)
+  }
+
+  /**
+   * Create a comment
+   */
+  @Post('/posts/:post@id(\\d+)', { bindings: { post: PostService } })
+  async create (event: IncomingHttpEvent): Promise<{ id?: number }> {
+    const id = await this.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
+   */
+  @Delete('/:id', { rules: { id: /\d+/ } })
+  async delete (event: IncomingHttpEvent): Promise<{ statusCode: number }> {
+    await this.commentService.delete(event.get<number>('id', 0))
+    this.logger.info(`Comment deleted: ${String(event.get<number>('id'))}, by user: ${String(event.getUser<User>()?.id)}`)
+    return { statusCode: 204 }
+  }
+}

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

@@ -0,0 +1,104 @@
+import { User } from '../models/User'
+import { ILogger } from '@stone-js/core'
+import { PostService } from '../services/PostService'
+import { PostModel, PostResponse } from '../models/Post'
+import { Delete, EventHandler, Get, Patch, Post } from '@stone-js/router'
+import { IncomingHttpEvent, InternalServerError, JsonHttpResponse } from '@stone-js/http-core'
+
+/**
+ * Post Event Handler Options
+ */
+export interface PostEventHandlerOptions {
+  logger: ILogger
+  postService: PostService
+}
+
+/**
+ * Post Event Handler
+ *
+ * @EventHandler() is a decorator that marks a class as a handler.
+ * It acts like a controller in other frameworks.
+ */
+@EventHandler('/posts', { name: 'posts' })
+export class PostEventHandler {
+  private readonly logger: ILogger
+  private readonly postService: PostService
+
+  /**
+   * Create a new instance of PostEventHandler
+   *
+   * @param postService
+   * @param logger
+   */
+  constructor ({ postService, logger }: PostEventHandlerOptions) {
+    this.logger = logger
+    this.postService = postService
+  }
+
+  /**
+   * List all posts
+   */
+  @Get('/', { name: 'list' })
+  @JsonHttpResponse(200)
+  async list (event: IncomingHttpEvent): Promise<PostResponse[]> {
+    return await this.postService.list(event.get<number>('limit', 10))
+  }
+
+  /**
+   * List all posts by a specific author
+   */
+  @Get('/authors/:id(\\d+)', { name: 'listByAuthor' })
+  @JsonHttpResponse(200)
+  async listByAuthor (event: IncomingHttpEvent): Promise<PostResponse[]> {
+    return await this.postService.listByAuthor(
+      event.get<number>('id', 0),
+      event.get<number>('limit', 10)
+    )
+  }
+
+  /**
+   * Show a post by ID
+   */
+  @Get('/:post@id(\\d+)', { bindings: { post: PostService } })
+  show (event: IncomingHttpEvent): PostResponse {
+    return event.get<PostResponse>('post', {} as unknown as PostResponse)
+  }
+
+  /**
+   * Create a post
+   */
+  @Post('/')
+  async create (event: IncomingHttpEvent): Promise<{ id?: number }> {
+    const id = await this.postService.create({
+      ...event.getBody<PostModel>({} as any),
+      authorId: event.getUser<User>()?.id ?? 0
+    })
+
+    return { id: Number(id) }
+  }
+
+  /**
+   * Update a post
+   */
+  @Patch('/:id', { rules: { id: /\d+/ } })
+  @JsonHttpResponse(204)
+  async update (event: IncomingHttpEvent): Promise<void> {
+    const updated = await this.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
+   */
+  @Delete('/:id', { rules: { id: /\d+/ } })
+  async delete (event: IncomingHttpEvent): Promise<{ statusCode: number }> {
+    const deleted = await this.postService.delete(event.get<number>('id', 0))
+    if (!deleted) {
+      throw new InternalServerError(`Failed to update post with ID ${String(event.get<number>('id'))}`)
+    }
+    this.logger.info(`Post deleted: ${String(event.get<number>('id'))}, by user: ${String(event.getUser<User>()?.id)}`)
+    return { statusCode: 204 }
+  }
+}

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

@@ -0,0 +1,108 @@
+import { ILogger } from '@stone-js/core'
+import { EventHandler, Post } from '@stone-js/router'
+import { SecurityService } from '../services/SecurityService'
+import { IncomingHttpEvent, NoContentHttpResponse } from '@stone-js/http-core'
+import { UserChangePassword, UserLogin, UserRegister, UserToken } from '../models/User'
+
+/**
+ * Security Event Handler Options
+*/
+export interface SecurityEventHandlerOptions {
+  logger: ILogger
+  securityService: SecurityService
+}
+
+/**
+ * Security Event Handler
+ *
+ * @EventHandler() is a decorator that marks a class as a handler.
+ * @EventHandler() think about it as a controller in other frameworks.
+ * Stone.js also provides a @Controller() decorator that is an alias to @EventHandler().
+ * If you are familiar with other frameworks, you can use @Controller() instead of @EventHandler().
+*/
+@EventHandler('/', { name: 'security' })
+export class SecurityEventHandler {
+  private readonly logger: ILogger
+  private readonly securityService: SecurityService
+
+  /**
+   * Create a new instance of SecurityEventHandler
+   *
+   * @param securityService
+   * @param logger
+   */
+  constructor ({ securityService, logger }: SecurityEventHandlerOptions) {
+    this.logger = logger
+    this.securityService = securityService
+  }
+
+  /**
+   * Login a user
+   *
+   * @param event - IncomingHttpEvent
+   * @returns UserToken
+  */
+  @Post('/login', { name: 'login' })
+  async login (event: IncomingHttpEvent): Promise<UserToken> {
+    return await this.securityService.login(
+      event,
+      event.getBody<UserLogin>({ email: '', password: '' })
+    )
+  }
+
+  /**
+   * Logout a user
+   *
+   * @param event - IncomingHttpEvent
+   * @returns void
+  */
+  @Post('/logout', { name: 'logout' })
+  @NoContentHttpResponse({ 'content-type': 'application/json' })
+  async logout (event: IncomingHttpEvent): Promise<void> {
+    await this.securityService.logout(
+      event.get<string>('Authorization', '').replace('Bearer ', '')
+    )
+  }
+
+  /**
+   * Refresh a token
+   *
+   * @param event - IncomingHttpEvent
+   * @returns UserToken
+  */
+  @Post('/refresh', { name: 'refresh' })
+  async refresh (event: IncomingHttpEvent): Promise<UserToken> {
+    return await this.securityService.refresh(
+      event.get<string>('Authorization', '').replace('Bearer ', '')
+    )
+  }
+
+  /**
+   * Register a user
+   *
+   * @param event - IncomingHttpEvent
+   * @returns UserToken
+  */
+  @Post('/register', { name: 'register' })
+  @NoContentHttpResponse({ 'content-type': 'application/json' })
+  async register (event: IncomingHttpEvent): Promise<void> {
+    await this.securityService.register(
+      event.getBody<UserRegister>({} as any)
+    )
+  }
+
+  /**
+   * Change password
+   *
+   * @param event - IncomingHttpEvent
+   * @returns void
+  */
+  @Post('/change-password', { name: 'change-password' })
+  @NoContentHttpResponse({ 'content-type': 'application/json' })
+  async changePassword (event: IncomingHttpEvent): Promise<void> {
+    await this.securityService.changePassword(
+      event.getUser(),
+      event.getBody<UserChangePassword>()
+    )
+  }
+}

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

@@ -0,0 +1,159 @@
+import { ILogger } from '@stone-js/core'
+import { File } from '@stone-js/filesystem'
+import { UserService } from '../services/UserService'
+import { User, UserModel, UserResponse } from '../models/User'
+import { IncomingHttpEvent, JsonHttpResponse } from '@stone-js/http-core'
+import { Delete, EventHandler, Get, Patch, Post } from '@stone-js/router'
+
+/**
+ * User Event Handler Options
+*/
+export interface UserEventHandlerOptions {
+  logger: ILogger
+  userService: UserService
+}
+
+/**
+ * User Event Handler
+ *
+ * @EventHandler() is a decorator that marks a class as a handler.
+ * @EventHandler() think about it as a controller in other frameworks.
+ * Stone.js also provides a @Controller() decorator that is an alias to @EventHandler().
+ * If you are familiar with other frameworks, you can use @Controller() instead of @EventHandler().
+*/
+@EventHandler('/users', { name: 'users' })
+export class UserEventHandler {
+  private readonly logger: ILogger
+  private readonly userService: UserService
+
+  /**
+   * Create a new instance of UserEventHandler
+   *
+   * @param userService
+   * @param logger
+   */
+  constructor ({ logger, userService }: UserEventHandlerOptions) {
+    this.logger = logger
+    this.userService = userService
+  }
+
+  /**
+   * List all users
+   *
+   * With explicit json response type.
+  */
+  @Get('/', { name: 'list' })
+  @JsonHttpResponse(200)
+  async list (event: IncomingHttpEvent): Promise<UserResponse[]> {
+    return await this.userService.list(event.get<number>('limit', 10))
+  }
+
+  /**
+   * Show current user
+   *
+   * @param event - IncomingHttpEvent
+   * @returns User
+  */
+  @Get('/me')
+  showCurrent (event: IncomingHttpEvent): UserResponse {
+    const user = { ...event.getUser<UserModel>(), password: undefined }
+    return user as UserResponse
+  }
+
+  /**
+   * Show a user
+   *
+   * With implicit rules definition.
+   * Explicit bindings definition for model resolution.
+   * Implicit json response type.
+   * Because literal object is returned as json.
+  */
+  @Get('/:user@id(\\d+)', { bindings: { user: UserService } })
+  show (event: IncomingHttpEvent): UserResponse {
+    return event.get<UserResponse>('user', {} as unknown as UserResponse)
+  }
+
+  /**
+   * Show a user avatar
+   *
+   * @param event - IncomingHttpEvent
+   * @returns File
+   * @throws FileError if the file is not valid.
+   * @throws NotFoundError if the user is not found.
+   */
+  @Get('/:user@id(\\d+)/avatar', { bindings: { user: UserService } })
+  avatar (event: IncomingHttpEvent): File {
+    const user = event.get<UserResponse>('user', {} as unknown as UserResponse)
+    return File.create(`public/uploads/${String(user.avatar)}`)
+  }
+
+  /**
+   * Create a user
+   *
+   * With explicit no content json response type.
+   * Using headers to define the content type.
+  */
+  @Post('/')
+  async create (event: IncomingHttpEvent): Promise<{ id?: number }> {
+    const id = await this.userService.create(this.handleFileUpload(event))
+    return { id: Number(id) }
+  }
+
+  /**
+   * Update the current user
+   *
+   * With explicit rules definition.
+  */
+  @Patch('/me')
+  @JsonHttpResponse(204)
+  async updateCurrent (event: IncomingHttpEvent): Promise<UserResponse> {
+    return await this.userService.update(
+      event.getUser<UserModel>()?.id ?? 0,
+      this.handleFileUpload(event)
+    )
+  }
+
+  /**
+   * Update a user
+   *
+   * With explicit rules definition.
+  */
+  @Patch('/:id', { rules: { id: /\d+/ } })
+  @JsonHttpResponse(204)
+  async update (event: IncomingHttpEvent): Promise<UserResponse> {
+    return await this.userService.update(
+      event.get<number>('id', 0),
+      this.handleFileUpload(event)
+    )
+  }
+
+  /**
+   * Delete a user
+   *
+   * Explcitily returning a status code.
+  */
+  @Delete('/:id')
+  async delete (event: IncomingHttpEvent): Promise<{ statusCode: number }> {
+    await this.userService.delete(event.get<number>('id', 0))
+    this.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
+  */
+  private 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
+  }
+}

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

@@ -0,0 +1,35 @@
+import { UserEvent } from '../events/UserEvent'
+import { IEventListener, ILogger, Listener } from '@stone-js/core'
+
+/**
+ * User Event Listener Options
+*/
+export interface UserEventListenerOptions {
+  logger: ILogger
+}
+
+/**
+ * User event listener
+ */
+@Listener({ event: UserEvent.USER_CREATED })
+export class UserEventListener implements IEventListener<UserEvent> {
+  private readonly logger: ILogger
+
+  /**
+   * Create a new instance of UserEventListener
+   *
+   * @param logger
+   */
+  constructor ({ logger }: UserEventListenerOptions) {
+    this.logger = logger
+  }
+
+  /**
+   * Handle the UserEvent
+   *
+   * @param event - The event to handle
+   */
+  handle (event: UserEvent): void {
+    this.logger.info('User event listener', event)
+  }
+}

package/full-service-declarative/app/middleware/AuthMiddleware.ts

@@ -0,0 +1,54 @@
+import { SecurityService } from '../services/SecurityService'
+import { IMiddleware, Middleware, NextMiddleware } from '@stone-js/core'
+import { IncomingHttpEvent, OutgoingHttpResponse } from '@stone-js/http-core'
+
+/**
+ * Auth middleware Options
+*/
+export interface AuthMiddlewareOptions {
+  securityService: SecurityService
+}
+
+/**
+ * Auth middleware
+ */
+@Middleware({
+  global: true,
+  params: [['/login', '/register']]
+})
+export class AuthMiddleware implements IMiddleware<IncomingHttpEvent, OutgoingHttpResponse> {
+  private readonly securityService: SecurityService
+
+  /**
+   * Create a new instance of AuthMiddleware
+   *
+   * @param options - The options to create the middleware
+   */
+  constructor ({ securityService }: AuthMiddlewareOptions) {
+    this.securityService = securityService
+  }
+
+  /**
+   * Handle the incoming event
+   *
+   * @param event - The incoming event
+   * @param next - The next middleware
+   * @returns The response
+   */
+  async handle (
+    event: IncomingHttpEvent,
+    next: NextMiddleware<IncomingHttpEvent, OutgoingHttpResponse>,
+    excludes: string[] = []
+  ): Promise<OutgoingHttpResponse> {
+    const isOptionsRequest = event.isMethod('OPTIONS')
+    const isExcludedPath = excludes.includes(event.pathname)
+
+    if (!isExcludedPath && !isOptionsRequest) {
+      const token = event.get<string>('Authorization', '').replace('Bearer ', '')
+      const user = await this.securityService.authenticate(token, event.ip, event.userAgent)
+      event.setUserResolver(() => user)
+    }
+
+    return await next(event)
+  }
+}

package/full-service-declarative/app/models/Comment.ts

@@ -0,0 +1,38 @@
+import { User } from './User'
+
+/**
+ * Comment Interface
+*/
+export interface CommentModel {
+  id: number
+  content: string
+  postId: number
+  authorId: number
+  createdAt: number
+}
+
+/**
+ * Comment Create Model Interface
+*/
+export interface CommentCreateModel extends Omit<CommentModel, 'id'> {}
+
+/**
+ * Comment Interface
+*/
+export interface Comment extends Omit<CommentModel, 'authorId'> {
+  author: User
+}
+
+/**
+ * Comment Create Request Interface
+ * Represents a comment create request resource.
+*/
+export interface CommentCreateRequest {
+  content: string
+}
+
+/**
+ * Comment Response Interface
+ * Represents a comment response resource.
+*/
+export interface CommentResponse extends Comment {}

package/full-service-declarative/app/models/Post.ts

@@ -0,0 +1,50 @@
+import { User } from './User'
+
+/**
+ * Post Model Interface
+*/
+export interface PostModel {
+  id: number
+  title: string
+  content: string
+  authorId: number
+  createdAt: number
+  updatedAt: number
+}
+
+/**
+ * Post Create Model Interface
+*/
+export interface PostCreateModel extends Omit<PostModel, 'id'> {}
+
+/**
+ * Post Interface
+*/
+export interface Post extends Omit<PostModel, 'authorId'> {
+  author: User
+}
+
+/**
+ * Post Create Request Interface
+ * Represents a post create request resource.
+*/
+export interface PostCreateRequest {
+  title: string
+  content: string
+}
+
+/**
+ * Post Update Request Interface
+ * Represents a post update request resource.
+*/
+export interface PostUpdateRequest {
+  id: number
+  title: string
+  content: string
+}
+
+/**
+ * Post Response Interface
+ * Represents a post response resource.
+*/
+export interface PostResponse extends Post {}

package/full-service-declarative/app/models/Session.ts

@@ -0,0 +1,14 @@
+/**
+ * Session Interface
+*/
+export interface Session {
+  ip: string
+  id: number
+  uuid: string
+  userId: number
+  createdAt: number
+  expiresAt: number
+  lastActivityAt: number
+  closedAt?: number | null
+  userAgent?: string | null
+}