refactors

controllers/auth.ts

@@ -3,8 +3,7 @@ import User from '../models/user.js';
 import { StatusCodes } from 'http-status-codes';
 import { BadRequestError, UnauthenticatedError } from '../errors/index.js';
 
-const register = async (req: Request, res: Response) => {
-  console.log(req.body)
+export async function register(req: Request, res: Response) {
   // mongoose will validate
   // const { name, email, password } = req.body
   // if (!name || !email || !password) {
@@ -15,8 +14,7 @@ const register = async (req: Request, res: Response) => {
   res.status(StatusCodes.CREATED).json({ user: { name: user.fullName }, token: user.createJWT() });
 };
 
-const login = async (req: Request, res: Response) => {
-  console.log(req.headers);
+export async function login(req: Request, res: Response) {
   const { email, password } = req.body;
   if (!email || !password) throw new BadRequestError('Email and password are required');
   const user = await User.findOne({ email });
@@ -27,6 +25,4 @@ const login = async (req: Request, res: Response) => {
   } else {
     throw new UnauthenticatedError('Invalid credentials');
   }
-};
-
-export { register, login };
+};

controllers/widgets.ts

@@ -3,24 +3,25 @@ import { StatusCodes } from 'http-status-codes';
 import Widget from '../models/widget.js';
 import { BadRequestError, NotFoundError } from '../errors/index.js';
 
-const getAllWidgets = async (req: AuthenticatedRequest, res: Response) => {
+export async function index(req: AuthenticatedRequest, res: Response) {
   const widgets = await Widget.find({ createdBy: req.user.id }).sort('createdAt');
   res.status(StatusCodes.OK).json({ widgets, count: widgets.length });
-};
-
-const createWidget = async (req: AuthenticatedRequest, res: Response) => {
-  const widget = await Widget.create({ ...req.body, createdBy: req.user.id });
-  res.status(StatusCodes.CREATED).json({ widget });
-};
+}
 
-const getWidget = async (req: AuthenticatedRequest, res: Response) => {
+export async function show(req: AuthenticatedRequest, res: Response) {
   const { user: { id: userId }, params: { id: widgetId }} = req;
   const widget = await Widget.findOne({ _id: widgetId, createdBy: userId }).select('-createdAt -updatedAt');
   if (!widget) throw new NotFoundError(`No widget with id: ${widgetId}`);
   res.status(StatusCodes.OK).json({ widget });
 };
 
-const updateWidget = async (req: AuthenticatedRequest, res: Response) => {
+export async function create(req: AuthenticatedRequest, res: Response) {
+  const widget = await Widget.create({ ...req.body, createdBy: req.user.id });
+  res.status(StatusCodes.CREATED).json({ widget });
+};
+
+
+export async function update(req: AuthenticatedRequest, res: Response) {
   const { user: { id: userId }, body: { company, position }, params: { id: widgetId } } = req;
   if (!company || !position) throw new BadRequestError('Missing required fields');
 
@@ -34,11 +35,9 @@ const updateWidget = async (req: AuthenticatedRequest, res: Response) => {
   res.status(200).json({ widget });
 };
 
-const deleteWidget = async (req: AuthenticatedRequest, res: Response) => {
+export async function destroy(req: AuthenticatedRequest, res: Response) {
   const { user: { id: userId }, params: { id: widgetId }} = req;
   const widget = await Widget.findOneAndDelete({ _id: widgetId, createdBy: userId });
   if (!widget) throw new NotFoundError(`No widget with id: ${widgetId}`);
   res.status(200).send();
-};
-
-export { getAllWidgets, createWidget, getWidget, updateWidget, deleteWidget };
+};

errors/custom-error.ts

@@ -6,4 +6,4 @@ class CustomApiError extends Error {
   }
 }
 
-export default CustomApiError
+export default CustomApiError;

global.d.ts

@@ -1,4 +1,5 @@
 // https://dev.to/asjadanis/parsing-env-with-typescript-3jjm
+// https://stackoverflow.com/questions/45194598/using-process-env-in-typescript
 
 import { Request } from 'express';
 
@@ -16,6 +17,7 @@ declare global {
     }
   }
 
+  // https://blog.logrocket.com/extend-express-request-object-typescript/
   namespace Express {
     interface Request { 
       user?: RegisteredUser 

middleware/error-handler.ts

@@ -6,13 +6,12 @@ import { CustomApiError } from '../errors/index.js';
 
 type ErrorType = Error | MongooseError | MongoError | CustomApiError;
 
-const errorHandler = (err: ErrorType, req: Request, res: Response, next: NextFunction) => {
+export default function handleError(err: ErrorType, req: Request, res: Response, next: NextFunction) {
   const customError = {
     statusCode: (err instanceof CustomApiError && err.statusCode) || StatusCodes.INTERNAL_SERVER_ERROR,
     msg: (err instanceof CustomApiError && err.message) || 'Sorry, there was an error'
   }
   if (err instanceof MongooseError.ValidationError) {
-    console.log(Object.values(err.errors).map(item => item.message).join(','))
     customError.msg = Object.values(err.errors).map(item => item.message).join(', ');
     customError.statusCode = 400;
   }
@@ -21,12 +20,10 @@ const errorHandler = (err: ErrorType, req: Request, res: Response, next: NextFun
     customError.statusCode = 404;
   }
   if (err instanceof MongoError && err.code === 11000) {
+    // TODO: keyValue property is not defined on the underlying type? 
     // customError.msg = `That ${Object.keys(err.keyValue)} already exists`;
     customError.msg = 'Duplicate field'
     customError.statusCode = 400;
   }
-  // return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ err })
   res.status(customError.statusCode).json({ msg: customError.msg });
-}
-
-export default errorHandler;
+}

models/user.ts

@@ -2,7 +2,7 @@ import { Schema, type SchemaDefinition, model } from 'mongoose';
 import bcrypt from 'bcryptjs';
 import jwt from 'jsonwebtoken';
 
-interface IUser {
+interface User {
   firstName: string,
   lastName?: string,
   email: string,
@@ -44,9 +44,9 @@ const userAttributes: SchemaDefinition = {
   // }
 };
 const options = { timestamps: true };
-const userSchema = new Schema<IUser>(userAttributes, options);
+const userSchema = new Schema<User>(userAttributes, options);
 
-userSchema.virtual('fullName').get(function (this: IUser) { return `${this.firstName} ${this.lastName}`.trim(); });
+userSchema.virtual('fullName').get(function (this: User) { return `${this.firstName} ${this.lastName}`.trim(); });
 
 userSchema.pre('save', async function () {
   const salt = await bcrypt.genSalt(10);
@@ -66,4 +66,4 @@ userSchema.methods.comparePassword = async function (candidatePass: string) {
   return isMatch;
 }
 
-export default model<IUser>('User', userSchema);
+export default model<User>('User', userSchema);

models/widget.ts

@@ -1,6 +1,6 @@
 import { Schema, type SchemaDefinition, Types, model } from 'mongoose';
 
-interface IWidget {
+interface Widget {
   name: string,
   category: string,
   createdBy: Types.ObjectId
@@ -24,6 +24,6 @@ const widgetAttributes: SchemaDefinition = {
   }
 };
 const options = { timestamps: true };
-const widgetSchema = new Schema<IWidget>(widgetAttributes, options);
+const widgetSchema = new Schema<Widget>(widgetAttributes, options);
 
 export default model('Widget', widgetSchema);

routes/widgets.ts

@@ -1,18 +1,18 @@
 import type { RequestHandler } from 'express';
-import express from 'express';
-import { getAllWidgets, createWidget, getWidget, updateWidget, deleteWidget } from '../controllers/widgets.js';
+import { Router } from 'express';
+import { index, show, create, update, destroy } from '../controllers/widgets.js';
 
-const router = express.Router()
+const router = Router();
 
 // RequestHandler assertion is necessary due to argument being AuthenticatedRequest instead of Request
 // TODO: probably a better way to do this
 router.route('/')
-  .get(getAllWidgets as RequestHandler)
-  .post(createWidget as RequestHandler);
+  .get(index as RequestHandler)
+  .post(create as RequestHandler);
 
 router.route('/:id')
-  .get(getWidget as RequestHandler)
-  .put(updateWidget as RequestHandler)
-  .delete(deleteWidget as RequestHandler);
+  .get(show as RequestHandler)
+  .put(update as RequestHandler)
+  .delete(destroy as RequestHandler);
 
 export default router;

server.ts

@@ -1,4 +1,4 @@
-import type { Express, Request, Response } from 'express';
+import type { Request, Response } from 'express';
 import express from 'express';
 import 'express-async-errors';
 
@@ -18,10 +18,10 @@ import widgetsRouter from './routes/widgets.js';
 // middleware
 import authenticateUser from './middleware/auth.js';
 import handleNotFound from './middleware/not-found.js';
-import handleErrors from './middleware/error-handler.js';
+import handleError from './middleware/error-handler.js';
 
 const appName = 'node-api';
-const app: Express = express();
+const app = express();
 
 app
   .get('/', (req: Request, res: Response) => res.send('node api'))   // just a sanity check
@@ -38,7 +38,7 @@ app
   .use('/api/v1/auth', authRouter)
   .use('/api/v1/widgets', authenticateUser, widgetsRouter)
   .use(handleNotFound)
-  .use(handleErrors);
+  .use(handleError);
 
 connectDb(`${config.MONGO_URI}/${appName}`)
   .then(start)