Merge pull request #17 from oslabs-beta/orders

Orders yesssir

Author: seantokuzo

examples_new/microservices/orders/package-lock.json

@@ -4,9 +4,43 @@
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start": "ts-node-dev ./src/index.ts",
+    "test": "jest --watchAll --no-cache"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "setupFilesAfterEnv": [
+      "./src/test/setup.ts"
+    ]
   },
   "keywords": [],
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "dependencies": {
+    "@chronosrx/common": "^1.0.2",
+    "axios": "^1.6.2",
+    "bcryptjs": "^2.4.3",
+    "cookie-parser": "^1.4.6",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "express-async-errors": "^3.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.0.3",
+    "ts-node-dev": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/cookie-parser": "^1.4.6",
+    "@types/express": "^4.17.21",
+    "@types/jest": "^29.5.11",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/supertest": "^2.0.16",
+    "jest": "^29.7.0",
+    "mongodb-memory-server": "^9.1.1",
+    "supertest": "^6.3.3",
+    "ts-jest": "^29.1.1"
+  }
 }
+
+

examples_new/microservices/orders/package.json

@@ -0,0 +1,16 @@
+import request from 'supertest';
+import { app } from '../app';
+// Mongo Memory Server - Users collection always starts out empty**
+it('success if there is itemid and units', async () => {
+  const itemId = '6581bbc692686e6e68d25d7d';
+  const sellerID = '123123';
+  await global.createItem(itemId);
+  const response = await request(app)
+    .get('/api/orders/getMyOrder')
+    .send({
+      itemId: itemId,
+    })
+    .expect(200);
+  // console.log(response);
+  expect(response.body.units).toEqual(50);
+});

examples_new/microservices/orders/src/__test__/Order.test.ts

@@ -0,0 +1,29 @@
+import express from 'express';
+import 'express-async-errors';
+import dotenv from 'dotenv';
+dotenv.config();
+import { NotFoundError, errorHandler } from '@chronosrx/common';
+import cookieParser from 'cookie-parser';
+import orderRouter from './routes/order-router';
+import eventRouter from './routes/event-router';
+
+const app = express();
+
+app.use(express.json());
+app.use(cookieParser());
+
+// app.get('/', (req, res) => {
+//   console.log('💥 Test Route');
+//   res.status(200).send({ msg: '💥 Test route' });
+// });
+
+app.use('/api/orders', orderRouter);
+app.use('/events', eventRouter);
+
+app.use('*', (req, res) => {
+  throw new NotFoundError();
+});
+
+app.use(errorHandler);
+
+export { app };

examples_new/microservices/orders/src/app.ts

@@ -0,0 +1,51 @@
+import { Request, Response } from 'express';
+import axios from 'axios';
+import { Order } from '../models/Order';
+import { BadRequestError, CurrentUserRequest, Events } from '@chronosrx/common';
+import { Inventory } from '../models/Inventory';
+
+export const createOrder = async (req: CurrentUserRequest, res: Response) => {
+  //deconstruct req.body
+  const buyerId = req.currentUser;
+  const { itemId, amount, totalPrice, sellerId } = req.body;
+  //create Order document in the databse
+  const newOrder = Inventory.build({});
+  await newOrder.save();
+  //send created order to event bus
+  await axios.post('http://localhost:3005/', {
+    event: {
+      type: Events.ORDER_CREATED,
+      payload: newOrder,
+    },
+  });
+  res.status(201).send(newOrder);
+};
+
+export const getOrder = async (req: Request, res: Response) => {
+  // check if order already exists
+  const { buyerId } = req.body;
+  const exsitingOrder = await Order.findOne({ buyerId });
+  if (!exsitingOrder) {
+    throw new BadRequestError('Order with that id does not exists');
+  }
+  //check inventory itemId, amount
+  res.status(200).send(exsitingOrder);
+};
+
+export const getSale = async (req: Request, res: Response) => {
+  const { sellerId } = req.body;
+  const sales = await Order.find({ sellerId });
+  if (!sales) {
+    throw new BadRequestError('Sales with that sellerId does not exist');
+  }
+  res.status(200).send(sales);
+};
+
+export const deleteOrder = async (req: Request, res: Response) => {
+  const { id } = req.body;
+  const deletedOrder = await Order.findOneAndDelete({ id });
+  if (!deletedOrder) {
+    throw new BadRequestError(`Could not find that order by id to delete`);
+  }
+  res.status(200).send(deletedOrder);
+};

examples_new/microservices/orders/src/controllers/order-controller.ts

@@ -0,0 +1,24 @@
+import { DbConnectionError } from '@chronosrx/common';
+import { app } from './app';
+import mongoose from 'mongoose';
+
+const PORT = process.env.PORT || 3000;
+
+const start = async () => {
+  if (!process.env.MONGO_URI) throw new Error('MONGO_URI must be defined');
+  if (!process.env.JWT_KEY) throw new Error('JWT_KEY must be defined');
+//   if (!process.env.JWT_LIFETIME) throw new Error('JWT_LIFETIME must be defined');
+
+  try {
+    await mongoose.connect(process.env.MONGO_URI, {});
+    console.log('🍃 Connected to MongoDB');
+  } catch (err) {
+    throw new DbConnectionError();
+  }
+
+  app.listen(PORT, async () => {
+    console.log(`💥 App listening on ${PORT}`);
+  });
+};
+
+start();

examples_new/microservices/orders/src/index.ts

@@ -0,0 +1,62 @@
+import mongoose from 'mongoose';
+interface InventoryAttrs {
+  itemName: string;
+  sellerId: string; // some user's id)
+  unitPrice: number;
+}
+// define item attributes
+interface InventoryModel extends mongoose.Model<InventoryDoc> {
+  build(attrs: InventoryAttrs): InventoryDoc;
+}
+//create item data in the database with these types;
+interface InventoryDoc extends mongoose.Document {
+  itemName: string;
+  sellerId: string;
+  unitPrice: number;
+  itemId: string;
+  units: number;
+}
+// create the Schema in mongoose with defines requirements
+const InventorySchema = new mongoose.Schema(
+  {
+    itemName: {
+      type: String,
+      required: true,
+      // unique: true,
+    },
+    sellerId: {
+      type: mongoose.Types.ObjectId,
+      required: true,
+      ref: 'User',
+    },
+    unitPrice: {
+      type: Number,
+      required: true,
+    },
+    itemId: {
+      type: mongoose.Types.ObjectId,
+      required: true,
+      unique: true,
+    },
+    units: {
+      type: Number,
+      required: true,
+    },
+  },
+  {
+    //anytime we create JSON formatted data, transform item using following rules
+    toJSON: {
+      transform(doc, ret) {
+        ret.id = ret._id;
+        delete ret._id;
+        delete ret.__v;
+      },
+    },
+  }
+);
+InventorySchema.statics.build = (attrs: InventoryAttrs) => {
+  //returning item document with (attrs) passed in
+  return new Inventory(attrs);
+};
+const Inventory = mongoose.model<InventoryDoc, InventoryModel>('Inventory', InventorySchema);
+export { Inventory };

examples_new/microservices/orders/src/models/Inventory.ts

@@ -0,0 +1,65 @@
+import mongoose from 'mongoose';
+//define type of objects that is being passed into build method
+interface OrderAttrs {
+  itemId: string;
+  amount: number;
+  totalPrice: number;
+  sellerId: string;
+}
+
+interface OrderModel extends mongoose.Model<OrderDoc> {
+  build(attrs: OrderAttrs): OrderDoc;
+}
+//create inventory data in the database in this shape
+interface OrderDoc extends mongoose.Document {
+  itemId: string;
+  amount: number;
+  totalPrice: number;
+  sellerId: string;
+}
+
+//create the Schema in mongoose with defined requirements
+const OrderSchema = new mongoose.Schema(
+  {
+    itemId: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    amount: {
+      type: Number,
+      required: true,
+    },
+    totalPrice: {
+      type: Number,
+      required: true,
+    },
+    sellerId: {
+      type: String,
+      require: true,
+    },
+  },
+  {
+    //anytime we create Json formatted data, transform the user document as following
+    toJSON: {
+      transform(doc, ret) {
+        ret.id = ret._id;
+        delete ret._id;
+        delete ret.__v;
+      },
+    },
+  }
+);
+
+OrderSchema.statics.build = (attrs: OrderAttrs) => {
+  return new Order({
+    itemId: attrs.itemId,
+    amount: attrs.amount,
+    totalPrice: attrs.totalPrice,
+    sellerId: attrs.sellerId,
+  });
+};
+
+const Order = mongoose.model<OrderDoc, OrderModel>('Order', OrderSchema);
+
+export { Order };

examples_new/microservices/orders/src/models/Order.ts

@@ -0,0 +1,23 @@
+import express from 'express';
+import { Events } from '@chronosrx/common';
+import { Order } from '../models/Order';
+import { Inventory } from '../models/Inventory';
+
+const router = express.Router();
+
+router.post('/', async (req, res) => {
+  const { event } = req.body;
+  console.log(event);
+  switch (event.type) {
+    case Events.ITEM_CREATED:
+      const newOrder = Inventory.build(event.payload);
+      await newOrder.save();
+      break;
+    default:
+      res.send({});
+  }
+
+  res.send({ message: '🎃 Event received' });
+});
+
+export default router;

examples_new/microservices/orders/src/routes/event-router.ts

@@ -0,0 +1,13 @@
+import express from 'express';
+import { getOrder, getSale, createOrder, deleteOrder } from '../controllers/order-controller';
+import { currentUser, requireAuth } from '@chronosrx/common';
+
+const router = express.Router();
+router.use(currentUser);
+router.use(requireAuth);
+router.get('/getMyOrders', getOrder);
+router.get('/getMySales', getSale);
+router.post('/createOrder', createOrder);
+router.delete('/deleteOrder', deleteOrder);
+
+export default router;

examples_new/microservices/orders/src/routes/order-router.ts

@@ -0,0 +1,46 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import mongoose from 'mongoose';
+import { app } from '../app';
+import request from 'supertest';
+import { Order } from '../models/Order';
+
+declare global {
+  function createOrder(itemId: string, sellerId: string): void;
+}
+
+let mongo: any;
+
+beforeAll(async () => {
+  process.env.JWT_KEY = 'erreoivcxspasfgj';
+
+  mongo = await MongoMemoryServer.create();
+  const mongoUri = mongo.getUri();
+
+  await mongoose.connect(mongoUri, {});
+});
+
+beforeEach(async () => {
+  const collections = await mongoose.connection.db.collections();
+
+  for (let collection of collections) {
+    await collection.deleteMany({});
+  }
+});
+
+afterAll(async () => {
+  if (mongo) {
+    await mongo.stop();
+  }
+
+  await mongoose.connection.close();
+});
+
+global.createOrder = async (itemId, sellerId) => {
+  const data = Order.build({
+    itemId: itemId,
+    amount: 50,
+    totalPrice: 5000,
+    sellerId: sellerId,
+  });
+  await data.save();
+};