@next-k8s/tickets 1.0.25 → 1.0.28

package/src/events/listeners/__test__/order-cancelled.test.ts

@@ -0,0 +1,50 @@
+import mongoose from 'mongoose'
+import { Message } from 'node-nats-streaming'
+import { OrderCancelledEvent, OrderStatus } from '@next-k8s/common'
+
+import Ticket from '../../../models/ticket'
+import natsClient from '../../../nats-client'
+import OrderCancelledListener from '../order-cancelled'
+
+const setup = async () => {
+  const owner = new mongoose.Types.ObjectId().toHexString()
+  const orderId = new mongoose.Types.ObjectId().toHexString()
+  const listener = new OrderCancelledListener(natsClient.client)
+  const ticket = new Ticket({ title: 'Test Ticket', price: 21000, owner })
+
+  ticket.set({ orderId })
+  await ticket.save()
+
+  const data: OrderCancelledEvent['data'] = {
+    id: new mongoose.Types.ObjectId().toHexString(),
+    version: 0,
+    ticket: {
+      id: ticket.id
+    }
+  }
+
+  // @ts-ignore
+  const message: Message = { ack: jest.fn() }
+  return { data, listener, message, orderId, ticket }
+}
+
+describe('[Order Cancelled] Listener', () => {
+  it('should clear the orderId of the ticket', async () => {
+    const { data, listener, message, ticket } = await setup()
+    await listener.onMessage(data, message)
+    const updatedTicket = await Ticket.findById(ticket.id)
+    expect(updatedTicket.orderId).not.toBeDefined()
+  })
+
+  it('should ack the message', async () =>{
+    const { data, listener, message } = await setup()
+    await listener.onMessage(data, message)
+    expect(message.ack).toHaveBeenCalled()
+  })
+
+  it('should publish an order:updated event', async () => {
+    const { data, listener, message } = await setup()
+    await listener.onMessage(data, message)
+    expect(natsClient.client.publish).toHaveBeenCalled()
+  })
+})

package/src/events/listeners/__test__/order-created.test.ts

@@ -0,0 +1,50 @@
+import mongoose from 'mongoose'
+import { Message } from 'node-nats-streaming'
+import { OrderCreatedEvent, OrderStatus } from '@next-k8s/common'
+
+import Ticket from '../../../models/ticket'
+import natsClient from '../../../nats-client'
+import OrderCreatedListener from '../order-created'
+
+const setup = async () => {
+  const listener = new OrderCreatedListener(natsClient.client)
+  const ticket = new Ticket({ title: 'Test Ticket', price: 21000, owner: new mongoose.Types.ObjectId().toHexString() })
+  await ticket.save()
+
+  const data: OrderCreatedEvent['data'] = {
+    id: new mongoose.Types.ObjectId().toHexString(),
+    version: 0,
+    status: OrderStatus.Created,
+    owner: new mongoose.Types.ObjectId().toHexString(),
+    expiresAt: new Date().toUTCString(),
+    ticket: {
+      id: ticket.id,
+      price: ticket.price
+    }
+  }
+
+  // @ts-ignore
+  const message: Message = { ack: jest.fn() }
+  return { data, listener, message, ticket }
+}
+
+describe('[Order Created] Listener', () => {
+  it('should set the ticket orderId', async () => {
+    const { data, listener, message, ticket } = await setup()
+    await listener.onMessage(data, message)
+    const updatedTicket = await Ticket.findById(ticket.id)
+    expect(updatedTicket.orderId).toBe(data.id)
+  })
+
+  it('should ack the message', async () =>{
+    const { data, listener, message } = await setup()
+    await listener.onMessage(data, message)
+    expect(message.ack).toHaveBeenCalled()
+  })
+
+  it('should publish a ticket:updated event', async () => {
+    const { data, listener, message } = await setup()
+    await listener.onMessage(data, message)
+    expect(natsClient.client.publish).toHaveBeenCalled()
+  })
+})

package/src/events/listeners/_queue-group-name.ts

@@ -0,0 +1 @@
+export default 'tickets-service'

package/src/events/listeners/order-cancelled.ts

@@ -0,0 +1,24 @@
+import { Listener, NotFoundError, OrderCancelledEvent, Subjects } from '@next-k8s/common'
+import { Message } from 'node-nats-streaming'
+import Ticket from '../../models/ticket'
+import TicketUpdatedPublisher from '../publishers/updated'
+
+import queueGroupName from './_queue-group-name'
+
+export class OrderCancelledListener extends Listener<OrderCancelledEvent> {
+  readonly subject = Subjects.OrderCancelled
+  queueGroupName = queueGroupName
+
+  async onMessage (data: OrderCancelledEvent['data'], msg: Message) {
+    const ticket = await Ticket.findById(data.ticket.id)
+    if (!ticket) throw new NotFoundError('Ticket not found')
+    ticket.set({ orderId: undefined })
+    await ticket.save()
+
+    const { id, version, price, title, owner, orderId } = ticket
+    await new TicketUpdatedPublisher(this.client).publish({ id, version, price, title, owner, orderId })
+    msg.ack()
+  }
+}
+
+export default OrderCancelledListener

package/src/events/listeners/order-created.ts

@@ -0,0 +1,24 @@
+import { Listener, NotFoundError, OrderCreatedEvent, Subjects } from '@next-k8s/common'
+import { Message } from 'node-nats-streaming'
+import Ticket from '../../models/ticket'
+import TicketUpdatedPublisher from '../publishers/updated'
+
+import queueGroupName from './_queue-group-name'
+
+export class OrderCreatedListener extends Listener<OrderCreatedEvent> {
+  readonly subject = Subjects.OrderCreated
+  queueGroupName = queueGroupName
+
+  async onMessage (data: OrderCreatedEvent['data'], msg: Message) {
+    const ticket = await Ticket.findById(data.ticket.id)
+    if (!ticket) throw new NotFoundError('Ticket not found')
+    ticket.set({ orderId: data.id })
+    await ticket.save()
+
+    const { id, version, price, title, owner, orderId } = ticket
+    await new TicketUpdatedPublisher(this.client).publish({ id, version, price, title, owner, orderId })
+    msg.ack()
+  }
+}
+
+export default OrderCreatedListener

package/src/index.ts

@@ -2,6 +2,8 @@ import mongoose from 'mongoose'
 
 import natsClient from './nats-client'
 import app from './app'
+import OrderCreatedListener from './events/listeners/order-created'
+import OrderCancelledListener from './events/listeners/order-cancelled'
 
 const start = async () => {
   if (!process.env.JWT_KEY) throw new Error('JWT_KEY is undefined')
@@ -20,6 +22,9 @@ const start = async () => {
   process.on('SIGINT', () => natsClient.client.close())
   process.on('SIGTERM', () => natsClient.client.close())
 
+  new OrderCreatedListener(natsClient.client).listen()
+  new OrderCancelledListener(natsClient.client).listen()
+
   await mongoose.connect(process.env.MONGO_URI)
   console.log('Database connected!')
   const port = process.env.PORT || 3000

package/src/models/__test__/ticket.test.ts

@@ -0,0 +1,37 @@
+import mongoose from 'mongoose'
+import Ticket from '../ticket'
+
+describe('[Models] Ticket Model', () => {
+  it('implements optimistic concurrency control', async () => {
+    const ticket = new Ticket({ title: 'Test Ticket', price: 20000, owner: new mongoose.Types.ObjectId().toHexString() })
+    await ticket.save()
+
+    const copies = [
+      await Ticket.findById(ticket.id),
+      await Ticket.findById(ticket.id)
+    ]
+
+    copies[0].set({ price: 15000 })
+    copies[1].set({ price: 23000 })
+
+    await copies[0].save()
+    
+    try {
+      await copies[1].save()
+    } catch {
+      return
+    }
+
+    throw new Error('Ticket was saved when it should not have been')
+  })
+
+  it('increments the version number on update', async () => {
+    const ticket = new Ticket({ title: 'Test Ticket', price: 20000, owner: new mongoose.Types.ObjectId().toHexString() })
+    await ticket.save()
+    expect(ticket.version).toEqual(0)
+    await ticket.save()
+    expect(ticket.version).toEqual(1)
+    await ticket.save()
+    expect(ticket.version).toEqual(2)
+  })
+})

package/src/models/ticket.ts

@@ -1,8 +1,9 @@
 import mongoose, { ObjectId } from 'mongoose'
+import { updateIfCurrentPlugin } from 'mongoose-update-if-current'
 
 interface TicketAttributes {
-  title: String;
-  price: Number;
+  title: string;
+  price: number;
   owner: string;
   createdAt?: Date;
   updatedAt?: Date;
@@ -22,10 +23,13 @@ const ticketSchema = new mongoose.Schema({
   owner: {
     type: mongoose.Schema.Types.ObjectId,
     required: true
+  },
+
+  orderId: {
+    type: String
   }
 }, {
   toJSON: {
-    versionKey: false,
     transform (doc, ret) {
       ret.id = ret._id
       delete ret._id
@@ -34,6 +38,9 @@ const ticketSchema = new mongoose.Schema({
   }
 })
 
+ticketSchema.set('versionKey', 'version')
+ticketSchema.plugin(updateIfCurrentPlugin)
+
 export const TicketModel = mongoose.model('Ticket', ticketSchema)
 export default class Ticket extends TicketModel {
   constructor(attributes: TicketAttributes) {

package/src/routes/__test__/get.test.ts

@@ -5,6 +5,21 @@ import { getTokenCookie } from '@next-k8s/common'
 import app from '../../app'
 import { createTicket } from '../../test/utils'
 
+describe('[List Tickets] Route: GET /api/tickets', () => {
+  it('should return a list of tickets', async () => {
+    const cookie = await getTokenCookie({ id: new mongoose.Types.ObjectId().toHexString() })
+    await createTicket(app, cookie)
+    await createTicket(app, cookie, 'Test Event 2', 40000)
+    const list = await request(app)
+      .get('/api/tickets')
+      .send()
+      .expect(200)
+
+    expect(list.body.tickets).toBeDefined()
+    expect(list.body.tickets.length).toEqual(2)
+  })
+})
+
 describe('[Get Ticket] Route: GET /api/tickets/:id', () => {
   it('should throw a BadRequestError if ticket ID is invalid', async () => {
     await request(app)

package/src/routes/__test__/update.test.ts

@@ -5,6 +5,7 @@ import { getTokenCookie } from '@next-k8s/common'
 import app from '../../app'
 import { createTicket } from '../../test/utils'
 import natsClient from '../../nats-client'
+import Ticket from '../../models/ticket'
 
 describe('[Update Ticket] Route: PUT /api/tickets/:id', () => {
   it('should throw a NotFoundError if the ticket does not exist', async () => {
@@ -100,4 +101,18 @@ describe('[Update Ticket] Route: PUT /api/tickets/:id', () => {
     await createTicket(app, cookie)
     expect(natsClient.client.publish).toHaveBeenCalled()
   })
+
+  it('should reject updates to a reserved ticket', async () => {
+    const cookie = await getTokenCookie({ id: new mongoose.Types.ObjectId().toHexString() })
+    const response = await createTicket(app, cookie)
+    const ticket = await Ticket.findById(response.body.ticket.id)
+    ticket.set({ orderId: new mongoose.Types.ObjectId().toHexString() })
+    await ticket.save()
+
+    await request(app)
+      .put(`/api/tickets/${response.body.ticket.id}`)
+      .set('Cookie', [cookie])
+      .send({ title: 'Test Event 2', price: 33000 })
+      .expect(400)
+  })
 })

package/src/routes/create.ts

@@ -3,7 +3,7 @@ import { body } from 'express-validator'
 import { requireAuth, validateRequest } from '@next-k8s/common'
 
 import Ticket from '../models/ticket'
-import { TicketCreatedPublisher } from '../events/publishers/tickets/created'
+import TicketCreatedPublisher from '../events/publishers/created'
 import natsClient from '../nats-client'
 
 const router = express.Router()
@@ -17,7 +17,7 @@ router.post('/api/tickets', requireAuth, validateInput, validateRequest, async (
   const { title, price } = req.body
   const ticket = new Ticket({ title, price, owner: req.currentUser!.id })
   await ticket.save()
-  new TicketCreatedPublisher(natsClient.client).publish({ id: ticket.id, title: ticket.title, price: ticket.price, owner: ticket.owner })
+  new TicketCreatedPublisher(natsClient.client).publish({ id: ticket.id, version: ticket.version, title: ticket.title, price: ticket.price, owner: ticket.owner })
   res.status(201).send({ ticket })
 })
 

package/src/routes/get.ts

@@ -6,6 +6,11 @@ import Ticket from '../models/ticket'
 
 const router = express.Router()
 
+router.get('/api/tickets', async (req: Request, res: Response) => {
+  const tickets = await Ticket.find({})
+  res.send({ tickets })
+})
+
 router.get('/api/tickets/:id', async (req: Request, res: Response) => {
   if (!isValidObjectId(req.params.id)) throw new BadRequestError('Invalid Ticket ID')
   const ticket = await Ticket.findById(req.params.id)

package/src/routes/index.ts

@@ -1,6 +1,5 @@
 import getTicket from './get'
-import findTickets from './find'
 import createTicket from './create'
 import updateTicket from './update'
 
-export default [findTickets, getTicket, createTicket, updateTicket]
+export default [getTicket, createTicket, updateTicket]

package/src/routes/update.ts

@@ -2,9 +2,8 @@ import { BadRequestError, NotFoundError, UnauthorizedError, validateRequest, req
 import express, { Request, Response } from 'express'
 import { body } from 'express-validator'
 import { isValidObjectId } from 'mongoose'
-
 import Ticket from '../models/ticket'
-import TicketUpdatedPublisher from '../events/publishers/tickets/updated'
+import TicketUpdatedPublisher from '../events/publishers/updated'
 import natsClient from '../nats-client'
 
 const router = express.Router()
@@ -19,10 +18,11 @@ router.put('/api/tickets/:id', requireAuth, validateInput, validateRequest, asyn
   const ticket = await Ticket.findById(req.params.id)
   if (!ticket) throw new NotFoundError()
   if (ticket.owner.toHexString() !== req.currentUser!.id) throw new UnauthorizedError()
+  if (ticket.orderId) throw new BadRequestError('Ticket is reserved')
   const { title, price } = req.body
   ticket.set({ title, price })
   await ticket.save()
-  await new TicketUpdatedPublisher(natsClient.client).publish({ id: ticket.id, title: ticket.title, price: ticket.price, owner: ticket.owner })
+  await new TicketUpdatedPublisher(natsClient.client).publish({ id: ticket.id, version: ticket.version, title: ticket.title, price: ticket.price, owner: ticket.owner })
   res.json(ticket)
 })
 

package/src/routes/__test__/find.test.ts

@@ -1,22 +0,0 @@
-
-import mongoose from 'mongoose'
-import request from 'supertest'
-import { getTokenCookie } from '@next-k8s/common'
-
-import app from '../../app'
-import { createTicket } from '../../test/utils'
-
-describe('[List Tickets] Route: GET /api/tickets', () => {
-  it('should return a list of tickets', async () => {
-    const cookie = await getTokenCookie({ id: new mongoose.Types.ObjectId().toHexString() })
-    await createTicket(app, cookie)
-    await createTicket(app, cookie, 'Test Event 2', 40000)
-    const list = await request(app)
-      .get('/api/tickets')
-      .send()
-      .expect(200)
-
-    expect(list.body.tickets).toBeDefined()
-    expect(list.body.tickets.length).toEqual(2)
-  })
-})

package/src/routes/find.ts

@@ -1,11 +0,0 @@
-import express, { Request, Response } from 'express'
-import Ticket from '../models/ticket'
-
-const router = express.Router()
-
-router.get('/api/tickets', async (req: Request, res: Response) => {
-  const tickets = await Ticket.find({})
-  res.send({ tickets })
-})
-
-export default router