refactor: with-fastify example

Author: crashmax-dev

examples/with-fastify/src/api/posts/posts.controller.ts

@@ -0,0 +1,58 @@
+import { Post, User } from '../../dto/users.dto.js'
+import {
+ userIdAndPostIdParamsSchema,
+ userIdParamsSchema
+} from './posts.schema.js'
+import type { UserService } from '../users/users.service.js'
+import type { FastifyInstance } from 'fastify'
+
+export function postsController(
+ fastify: FastifyInstance,
+ service: UserService
+): void {
+ fastify.get('/', () => {
+ return service.userPosts
+ })
+
+ fastify.get<{ Params: { userId: number } }>(
+ '/:userId',
+ { schema: userIdParamsSchema },
+ (request, reply) => {
+ const user = service.findUserById(request.params.userId)
+ if (!user) return reply.status(404).send('User not found')
+ return user.posts
+ }
+ )
+
+ fastify.get<{ Params: { userId: number; postId: number } }>(
+ '/:userId/:postId',
+ { schema: userIdAndPostIdParamsSchema },
+ (request, reply) => {
+ const { userId, postId } = request.params
+ const user = service.findUserById(userId)
+ if (!user) return reply.status(404).send('User not found')
+
+ const post = user.findPost(postId)
+ if (!post) return reply.status(404).send('Post not found')
+ return post
+ }
+ )
+
+ fastify.post<{ Body: Post; Params: User }>(
+ '/:userId',
+ { schema: userIdParamsSchema },
+ async (request, reply) => {
+ const user = service.findUserById(request.params.userId)
+ if (!user) return reply.status(404).send('User not found')
+
+ const post = new Post(
+ user.postsLastId + 1,
+ request.body.subject,
+ new Date()
+ )
+ user.addPost(post)
+ await service.write()
+ return post
+ }
+ )
+}

examples/with-fastify/src/api/posts/posts.schema.ts

@@ -0,0 +1,18 @@
+export const userIdParamsSchema = {
+ params: {
+ userId: {
+ $ref: 'User#/properties/userId'
+ }
+ }
+}
+
+export const userIdAndPostIdParamsSchema = {
+ params: {
+ userId: {
+ $ref: 'User#/properties/userId'
+ },
+ postId: {
+ $ref: 'Post#/properties/postId'
+ }
+ }
+}

examples/with-fastify/src/api/users/users.controller.ts

@@ -0,0 +1,52 @@
+import { User } from '../../dto/users.dto.js'
+import { userIdParamsSchema } from '../posts/posts.schema.js'
+import { userBodySchema, userResponseSchema } from './users.schema.js'
+import type { UserService } from './users.service.js'
+import type { FastifyInstance } from 'fastify'
+
+export function userController(
+ fastify: FastifyInstance,
+ service: UserService
+): void {
+ fastify.get('/', () => {
+ return service.users
+ })
+
+ fastify.get<{ Params: User }>(
+ '/:userId',
+ {
+ schema: userIdParamsSchema
+ },
+ (request, reply) => {
+ const user = service.findUserById(request.params.userId)
+ if (!user) return reply.status(404).send('User not found')
+
+ return {
+ id: user.userId,
+ username: user.username,
+ age: user.age
+ }
+ }
+ )
+
+ fastify.post<{ Body: User }>(
+ '/',
+ { schema: userBodySchema },
+ async (request, reply) => {
+ const { username, age } = request.body
+ const newUser = service.addUser(username, age)
+ if (!newUser) return reply.status(400).send('Username exist')
+ return newUser
+ }
+ )
+
+ fastify.delete<{ Params: User }>(
+ '/:userId',
+ { schema: userResponseSchema },
+ async (request, reply) => {
+ const user = await service.deleteUser(request.params.userId)
+ if (!user) return reply.status(404).send('User not found')
+ return user
+ }
+ )
+}

examples/with-fastify/src/api/users/users.schema.ts

@@ -0,0 +1,9 @@
+export const userBodySchema = {
+ body: { $ref: 'User' }
+}
+
+export const userResponseSchema = {
+ response: {
+ 200: { $ref: 'User' }
+ }
+}

examples/with-fastify/src/api/users/users.service.ts

@@ -0,0 +1,63 @@
+import { User, Users } from '../../dto/users.dto.js'
+import type { Steno } from '@stenodb/fastify'
+import type { FastifyInstance } from 'fastify'
+
+export class UserService {
+ #users: Steno.NodeProvider<Users>
+
+ constructor(private readonly fastify: FastifyInstance) {
+ this.#users = this.fastify.steno.get<Users>('users')!
+ }
+
+ get users(): User[] {
+ return this.#users.data!.users
+ }
+
+ get userPosts() {
+ return this.users.map((user) => {
+ return {
+ id: user.userId,
+ posts: user.posts
+ }
+ })
+ }
+
+ get userLastId(): number {
+ return this.users.at(-1)!.userId
+ }
+
+ async write(): Promise<void> {
+ await this.#users.write()
+ }
+
+ async addUser(username: string, age: number): Promise<User | null> {
+ if (this.findUserByName(username)) return null
+
+ const user = new User(this.userLastId + 1, username.toLowerCase(), age)
+ this.users.push(user)
+ await this.write()
+
+ return user
+ }
+
+ findUserById(userId: number): User | undefined {
+ return this.users.find((user) => user.userId === userId)
+ }
+
+ findUserByName(userName: string): User | undefined {
+ return this.users.find((user) => user.username == userName)
+ }
+
+ async deleteUser(userId: number): Promise<User | null> {
+ const user = this.findUserById(userId)
+ if (user) {
+ this.#users.data!.users = this.users.filter(
+ (user) => user.userId !== userId
+ )
+ await this.write()
+ return user
+ }
+
+ return null
+ }
+}

examples/with-fastify/src/dto/users.dto.ts

@@ -0,0 +1,77 @@
+import { AsyncAdapter } from '@stenodb/fastify'
+import { Exclude, Type } from 'class-transformer'
+import { IsNumber, IsOptional, IsString, Length } from 'class-validator'
+
+export class Users {
+ @Type(() => User)
+ users: User[]
+
+ constructor(...users: User[]) {
+ this.users = users
+ }
+}
+
+export class User {
+ @Exclude({ toPlainOnly: true })
+ @IsNumber()
+ userId: number
+
+ @IsString()
+ @Length(3, 20)
+ username: string
+
+ @IsNumber()
+ age: number
+
+ @Exclude({ toPlainOnly: true })
+ @Type(() => Post)
+ posts: Post[]
+
+ constructor(userId: number, username: string, age: number, ...posts: Post[]) {
+ this.userId = userId
+ this.username = username
+ this.age = age
+ this.posts = posts
+ }
+
+ findPost(postId: number): Post | undefined {
+ return this.posts.find((post) => post.postId === postId)
+ }
+
+ addPost(post: Post) {
+ this.posts.push(post)
+ }
+
+ get postsLastId(): number {
+ return this.posts.at(-1)!.postId
+ }
+}
+
+export class Post {
+ @Exclude({ toPlainOnly: true })
+ @IsNumber()
+ postId: number
+
+ @IsString()
+ @Length(1, 128)
+ subject: string
+
+ @Exclude({ toPlainOnly: true })
+ @Type(() => Date)
+ createdAt: Date
+
+ constructor(postId: number, subject: string, createdAt: Date) {
+ this.postId = postId
+ this.subject = subject
+ this.createdAt = createdAt
+ }
+}
+
+const initialData = new Users(
+ new User(1, 'john', 18, new Post(1, 'Lorem ipsum', new Date())),
+ new User(2, 'alice', 23)
+)
+
+export const userEntities = [User, Post]
+
+export const users = new AsyncAdapter('users', Users, initialData)

examples/with-fastify/src/entities.ts

@@ -1,32 +1,44 @@
 import 'reflect-metadata'
 import { dirname, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { AsyncAdapter, FastifySteno } from '@stenodb/fastify'
+import { FastifySteno } from '@stenodb/fastify'
 import Fastify from 'fastify'
-import { Post, User, Users } from './entities.js'
+import { postsController } from './api/posts/posts.controller.js'
+import { userController } from './api/users/users.controller.js'
+import { UserService } from './api/users/users.service.js'
+import { userEntities, users } from './dto/users.dto.js'
 
 const fastify = Fastify()
 
 fastify.register(FastifySteno, {
  path: resolve(dirname(fileURLToPath(import.meta.url)), '..', 'db'),
- entities: [User, Post],
- adapters: [new AsyncAdapter('users', Users, new Users(new User('John', 18)))]
+ entities: [...userEntities],
+ adapters: [users]
 })
 
-fastify.get('/', () => {
- const users = fastify.steno.get<Users>('users')!
- return users.data
-})
+fastify.register(
+ (instance, _, done) => {
+ const userService = new UserService(fastify)
+
+ instance.register(
+ (instance, _, done) => {
+ userController(instance, userService)
+ done()
+ },
+ { prefix: '/users' }
+ )
+
+ instance.register(
+ (instance, _, done) => {
+ postsController(instance, userService)
+ done()
+ },
+ { prefix: '/posts' }
+ )
 
-fastify.post<{ Body: User }>(
- '/',
- { schema: { body: { $ref: 'User' } } },
- async (req) => {
- const users = fastify.steno.get<Users>('users')!
- users.data!.users.push(req.body)
- await users.write()
- return users.data
- }
+ done()
+ },
+ { prefix: '/api' }
 )
 
 fastify.get('/schemas', () => {