Import initial structure and code

Signed-off-by: Laurent Broudoux <[email protected]>

Author: lbroudoux

assets/order-service-architecture.png

@@ -0,0 +1,22 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+describe('AppController', () => {
+  let appController: AppController;
+
+  beforeEach(async () => {
+    const app: TestingModule = await Test.createTestingModule({
+      controllers: [AppController],
+      providers: [AppService],
+    }).compile();
+
+    appController = app.get<AppController>(AppController);
+  });
+
+  describe('root', () => {
+    it('should return "Hello World!"', () => {
+      expect(appController.getHello()).toBe('Hello World!');
+    });
+  });
+});

assets/order-service-ecosystem.png

@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}

src/.DS_Store

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+import { OrderModule } from './order/order.module';
+import { PastryModule } from './pastry/pastry.module';
+
+@Module({
+  imports: [OrderModule],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}

src/app.controller.spec.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

src/app.controller.ts

@@ -0,0 +1,8 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+bootstrap();

src/app.module.ts

@@ -0,0 +1,7 @@
+import { Order } from "../entities/order.entity"
+
+export class OrderEvent {
+  timestamp: number
+  order: Order
+  changeReason: string
+}

src/app.service.ts

@@ -0,0 +1,7 @@
+import { ProductQuantity } from "../entities/product-quantity.entity"
+
+export class OrderInfoDto {
+  customerId: string
+  productQuantities: ProductQuantity[]
+  totalPrice: number
+}

src/main.ts

@@ -0,0 +1,9 @@
+export class UnavailableProduct {
+  productName: string
+  details: string
+
+  constructor(productName: string, details: string) {
+    this.productName = productName;
+    this.details = details;
+  }
+}

src/order/.DS_Store

@@ -0,0 +1,6 @@
+export enum OrderStatus {
+  CREATED = 'CREATED',
+  VALIDATED = 'VALIDATED',
+  CANCELED = 'CANCELED',
+  FAILED = 'FAILED'
+}

src/order/dto/order-event.dto.ts

@@ -0,0 +1,12 @@
+import { uid } from 'uid';
+
+import { OrderStatus } from "./order-status"
+import { ProductQuantity } from "./product-quantity.entity"
+
+export class Order {
+  id: string = uid()
+  status: OrderStatus = OrderStatus.CREATED
+  customerId: string
+  productQuantities: ProductQuantity[]
+  totalPrice: number
+}

src/order/dto/order-info.dto.ts

@@ -0,0 +1,4 @@
+export class ProductQuantity {
+  productName: string
+  quantity: number
+}

src/order/dto/unavailable-product.dto.ts

@@ -0,0 +1,44 @@
+import { Controller, Inject, OnApplicationShutdown } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { ClientKafka, Ctx, EventPattern, KafkaContext, Payload, Transport } from "@nestjs/microservices";
+
+import { OrderService } from './order.service';
+import { OrderEvent } from "./dto/order-event.dto";
+
+@Controller('orders-listener')
+export class OrderEventListener implements OnApplicationShutdown {
+  consumer: any;
+
+  //constructor(private readonly orderService: OrderService) {}
+
+  constructor(configService: ConfigService,
+      private readonly orderService: OrderService,
+      @Inject('ORDER_SERVICE') private readonly client: ClientKafka) {
+
+    
+    // Add to go through this low-level stuff to get ConfigService topic name.
+    let kafka = client.createClient();
+    this.consumer = kafka.consumer({ groupId: 'order-service-consumer' })
+    this.consumer.subscribe({ topics: [configService.get<string>('order-events-reviewed.topic')], fromBeginning: false });
+    this.consumer.run({
+      eachMessage: async ({ topic, partition, message }) => {
+        console.log(`Received OrderEvent: ${message.value.toString()}`);  
+        this.orderService.updateReviewedOrder(JSON.parse(message.value.toString()) as OrderEvent);
+      },
+    })
+  }
+
+  onApplicationShutdown(signal: string) {
+    console.log('Disconnecting Kafka consumer');
+    this.consumer.disconnect();
+  }
+
+  // Using @EventPattern is more elegant but cannot find how to use the ConfigService to dynamically
+  // get the name of the topic to listen to.
+  /*
+  @EventPattern('OrderEventsAPI-0.1.0-orders-reviewed', Transport.KAFKA)
+  handleReviewedOrder(@Payload() message: OrderEvent, @Ctx() context: KafkaContext) {
+    console.log(`Topic: ${context.getTopic()}`);
+  }
+  */
+}

src/order/entities/order-status.ts

@@ -0,0 +1,14 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { OrderEvent } from './dto/order-event.dto';
+import { ClientKafka } from '@nestjs/microservices';
+
+@Injectable()
+export class OrderEventPublisher {
+  
+  constructor(@Inject('ORDER_SERVICE') private readonly client: ClientKafka) {}
+
+  publishOrderCreated(event: OrderEvent) {
+    console.log("Emitting order event");
+    this.client.emit<any>('orders-created', JSON.stringify(event));
+  }
+}

src/order/entities/order.entity.ts

@@ -0,0 +1,8 @@
+export class OrderNotFoundException extends Error {
+    id: string
+  
+    constructor(id: string) {
+      super();
+      this.id = id;
+    }
+  }

src/order/entities/product-quantity.entity.ts

@@ -0,0 +1,32 @@
+import { Controller, Post, Body, Res, HttpStatus } from '@nestjs/common';
+import { Response } from 'express';
+
+import { OrderService } from './order.service';
+import { UnavailablePastryError } from './unavailable-pastry.error';
+
+import { OrderInfoDto } from './dto/order-info.dto';
+import { UnavailableProduct } from './dto/unavailable-product.dto';
+
+
+@Controller('orders')
+export class OrderController {
+  constructor(private readonly orderService: OrderService) {}
+
+  @Post()
+  async create(@Body() orderInfo: OrderInfoDto, @Res() res: Response) {
+    let result = null;
+    try {
+      result = await this.orderService.create(orderInfo);
+    } catch (err) {
+      if (err instanceof UnavailablePastryError) {
+        return res.status(HttpStatus.UNPROCESSABLE_ENTITY)
+            .json(new UnavailableProduct(err.product, err.message))
+            .send();
+      } else {
+        return res.status(HttpStatus.INTERNAL_SERVER_ERROR).send();
+      }
+    }
+
+    return res.status(HttpStatus.CREATED).json(result).send();
+  }
+}

src/order/order-event.listener.ts

@@ -0,0 +1,65 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { ClientsModule, Transport } from '@nestjs/microservices';
+
+import { OrderService } from './order.service';
+import { OrderController } from './order.controller';
+import { PastryModule } from '../pastry/pastry.module';
+import { OrderEventListener } from './order-event.listener';
+import { OrderEventPublisher } from './order-event.publisher';
+
+
+@Module({
+  imports: [PastryModule,
+    ConfigModule.forRoot({
+      load: [() => ({
+        'brokers.url': 'localhost:9092',
+        'order-events-reviewed.topic': 'OrderEventsAPI-0.1.0-orders-reviewed'
+      })],
+    }),
+    ClientsModule.registerAsync([
+      {
+        name: 'ORDER_SERVICE',
+        imports: [ConfigModule],
+        useFactory:async(configService: ConfigService) => ({
+          transport: Transport.KAFKA,
+          options: {
+            client: {
+              clientId: 'order-service',
+              brokers: [configService.get<string>('brokers.url')],
+            },
+            consumer: {
+              groupId: 'order-service'
+            },
+            producer: {
+              allowAutoTopicCreation: true
+            }  
+          }
+        }),
+        inject: [ConfigService],
+      }
+    ])
+    
+    /*
+    ClientsModule.register([
+      {
+        name: 'ORDER_SERVICE',
+        transport: Transport.KAFKA,
+        options: {
+          client: {
+            clientId: 'order-service',
+            brokers: ['localhost:9092'],
+          },
+          consumer: {
+            groupId: 'order-service'
+          }
+        }
+      },
+    ]),
+    */
+    
+    ],
+  controllers: [OrderController, OrderEventListener],
+  providers: [OrderService, OrderEventPublisher],
+})
+export class OrderModule {}

src/order/order-event.publisher.ts

@@ -0,0 +1,88 @@
+import { Injectable } from '@nestjs/common';
+
+import { OrderInfoDto } from './dto/order-info.dto';
+
+import { Order } from './entities/order.entity';
+import { UnavailablePastryError } from './unavailable-pastry.error'
+
+import { Pastry } from '../pastry/pastry.dto';
+import { PastryService } from '../pastry/pastry.service';
+import { OrderEventPublisher } from './order-event.publisher';
+import { OrderEvent } from './dto/order-event.dto';
+import { OrderNotFoundException } from './order-not-found.error';
+
+@Injectable()
+export class OrderService {
+
+  orderEventsRepository: Map<string, OrderEvent[]> = new Map<string, OrderEvent[]>();
+
+  constructor(private readonly pastryService: PastryService,
+    private readonly orderEventPublisher: OrderEventPublisher) {}
+
+  /**
+   * 
+   * @param orderInfo 
+   * @returns 
+   * @throws {UnavailablePastryError}
+   */
+  async create(orderInfo: OrderInfoDto): Promise<Order> {
+    let pastryPromises: Promise<Pastry>[] = [];
+
+    for (var i=0; i<orderInfo.productQuantities.length; i++) {
+      let productQuantitiy = orderInfo.productQuantities[i];
+      pastryPromises.push(this.pastryService.getPastry(productQuantitiy.productName));
+    }
+
+    let pastries: PromiseSettledResult<Pastry>[] = await Promise.allSettled(pastryPromises)
+    for (var i=0; i<pastries.length; i++) {
+      let pastry = pastries[i];
+      if (pastry.status === 'fulfilled') {
+        if (pastry.value.status != 'available') {
+          throw new UnavailablePastryError("Pastry " + pastry.value.name + " is not available", pastry.value.name);
+        }
+      }
+    }
+    
+    let result = new Order();
+    result.customerId = orderInfo.customerId;
+    result.productQuantities = orderInfo.productQuantities;
+    result.totalPrice = orderInfo.totalPrice;
+
+    // Persist and publish creation event.
+    let orderEvent = new OrderEvent();
+    orderEvent.timestamp = Date.now();
+    orderEvent.order = result;
+    orderEvent.changeReason = 'Creation';
+    this.persistOrderEvent(orderEvent);
+    this.orderEventPublisher.publishOrderCreated(orderEvent)
+
+    return result;
+  }
+
+  /**
+   * 
+   * @param id 
+   * @returns 
+   * @throws {OrderNotFoundException}
+   */
+  getOrder(id: string): Order {
+    let orderEvents = this.orderEventsRepository.get(id);
+    if (orderEvents != undefined) {
+      return orderEvents[orderEvents.length - 1].order;
+    }
+    throw new OrderNotFoundException(id);
+  }
+
+  updateReviewedOrder(event: OrderEvent): void {
+    this.persistOrderEvent(event);
+  }
+
+  private persistOrderEvent(event: OrderEvent): void {
+    let orderEvents = this.orderEventsRepository.get(event.order.id);
+    if (orderEvents == undefined) {
+      orderEvents = [];
+    }
+    orderEvents.push(event);
+    this.orderEventsRepository.set(event.order.id, orderEvents);
+  }
+}

src/order/order-not-found.error.ts

@@ -0,0 +1,8 @@
+export class UnavailablePastryError extends Error {
+  product: string
+
+  constructor(message?: string, product?: string) {
+    super(message);
+    this.product = product;
+  }
+}