側欄 Use Case - Clean Architecture in TypeScript

 1export class CartItem {
 2	constructor(
 3		public readonly id: number, // index in the cart
 4		public readonly name: string,
 5		public readonly unitPrice: number,
 6		public readonly quantity: number,
 7	){}
 8
 9	get totalPrice(): number {
10		return this.unitPrice * this.quantity;
11	}
12}
13
14export class Cart {
15	private _items: CartItem[] = [];
16
17	constructor(
18		public readonly id: string
19	) {}
20
21	get items(): CartItem[] {
22		return [...this._items];
23	}
24
25	updateItem(name: string, unitPrice: number, quantity: number): void {
26		const existingItemIndex = this._items.findIndex(item => item.name === name);
27		if (existingItemIndex >= 0) {
28			this._items[existingItemIndex] = new CartItem(existingItemIndex, name, unitPrice, quantity);
29		} else {
30			const newItem = new CartItem(this._items.length, name, unitPrice, quantity);
31			this._items.push(newItem);
32		}
33	}
34
35	removeItem(name: string): void {
36		const itemIndex = this._items.findIndex(item => item.name === name);
37		if (itemIndex >= 0) {
38			this._items.splice(itemIndex, 1);
39			for (let i = itemIndex; i < this._items.length; i++) {
40				this._items[i] = new CartItem(i, this._items[i].name, this._items[i].unitPrice, this._items[i].quantity);
41			}
42		}
43	}
44}

1// ...
2
3export interface CartRepository {
4	byId(id: string): Promise<Cart>;
5}
6
7export interface CartPresenter {
8	addItem(item: CartItem): void;
9}

 1import { CartRepository, CartPresenter } from './interface';
 2
 3export class GetCartUsecase {
 4  constructor(
 5  	private readonly cartRepository: CartRepository,
 6  	private readonly cartPresenter: CartPresenter,
 7	){}
 8
 9	async execute(id: string): Promise<void> {
10		const cart = await this.cartRepository.byId(id);
11		cart.items.forEach((item) => {
12			this.cartPresenter.addItem(item);
13		});
14	}
15}

 1Reference to `src/controller/chat.ts` to refactor `src/controller/cart.ts` to use `GetCartUsecase`
 2
 3## CartRepository
 4
 5- Reference `KvChatMessageRepository` to implement `CartRepository` as `KvCartRepository`
 6- Save in memory for now
 7- Define `CartSchema` and `CartItemSchema` for saving in kv
 8- Predefine mock data in repository for development purposes
 9
10## CartPresenter
11
12- Reference `JsonChatMessagePresenter` to implement `CartPresenter` as `JsonCartPresenter`
13- Define `CartSchema` and `CartItemSchema` for presenting in json
14- Define `toJson` method to convert `Cart` to JSON

 1// ...
 2
 3const { text } = await generateText({
 4  model: openai(this.env.OPENAI_MODEL),
 5  system: `
 6  You are a helpful assistant that can answer questions and provide information about the shopping cart. You can also retrieve the current contents of the cart when requested.
 7  `,
 8  messages: aiMessages,
 9  maxSteps: 5,
10  tools: {
11    getCart: tool({
12      description: 'Get the current shopping cart contents',
13      parameters: z.object({}),
14      execute: async () => {
15        // TODO: use getCartUseCase
16        return { items: [] };
17      }
18    })
19  }
20});
21
22// ...

1// ...
2export interface AssistantService {
3	ask(chatId: string, messages: ChatMessage[]): Promise<string>;
4}

 1export class ChatWithAssistant {
 2
 3	// ...
 4	async execute(id: string, message: string): Promise<void> {
 5		// ...
 6
 7		await this.chatMessageRepository.save(id, newMessages);
 8
 9		newMessages.forEach((message) => {
10			this.chatMessagePresenter.addMessage(message);
11		});
12	}
13}

1Update `LlmAssistantService` to implement `getCart` tool.
2
3- The `cartId` is same as `chatId`
4- Use `getCartUsecase` to retrieve the cart.
5- Add `ToolCartPresenter` to format the cart response, use `toTool()` method.
6- Use dependency injection to provide repository and presenter
7- Create a new usecase in tool handler