feat: implement soft delete and archived status for deliveries

src/controllers/delivery.controller.ts

@@ -0,0 +1,152 @@
+import { Request, Response, NextFunction } from 'express';
+import httpStatus from 'http-status-codes';
+import { DeliveryStatus } from '../models/Delivery';
+import {
+  deliveryService,
+  CreateDeliveryInput,
+  UpdateDeliveryInput,
+  DeliveryFilter,
+} from '../services/delivery.service';
+
+interface AuthenticatedRequest extends Request {
+  user?: { id: string };
+}
+
+export class DeliveryController {
+  async create(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const input: CreateDeliveryInput = {
+        trackingNumber: req.body.trackingNumber,
+        customer: req.body.customer,
+        pickup: req.body.pickup,
+        dropoff: req.body.dropoff,
+        package: req.body.package,
+        deliveryFee: req.body.deliveryFee,
+        escrowAmount: req.body.escrowAmount,
+        notes: req.body.notes,
+      };
+
+      const delivery = await deliveryService.create(input);
+      res.status(httpStatus.CREATED).json({
+        status: 'success',
+        data: delivery,
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async getById(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const delivery = await deliveryService.getById(req.params.id);
+      res.status(httpStatus.OK).json({
+        status: 'success',
+        data: delivery,
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async list(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const statusParam = req.query.status as string | undefined;
+      const validatedStatus = Object.values(DeliveryStatus).includes(statusParam as DeliveryStatus)
+        ? (statusParam as DeliveryStatus)
+        : undefined;
+
+      const filters: DeliveryFilter = {
+        status: validatedStatus,
+        driver: req.query.driver as string | undefined,
+        search: req.query.search as string | undefined,
+        page: req.query.page ? parseInt(req.query.page as string, 10) : 1,
+        limit: req.query.limit ? parseInt(req.query.limit as string, 10) : 10,
+      };
+
+      const result = await deliveryService.list(filters);
+      res.status(httpStatus.OK).json({
+        status: 'success',
+        data: result.data,
+        meta: {
+          total: result.total,
+          page: result.page,
+          limit: result.limit,
+          totalPages: result.totalPages,
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async update(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const input: UpdateDeliveryInput = {
+        status: req.body.status,
+        driver: req.body.driver,
+        estimatedDistance: req.body.estimatedDistance,
+        estimatedDuration: req.body.estimatedDuration,
+        stellarTransactionId: req.body.stellarTransactionId,
+        notes: req.body.notes,
+      };
+
+      const delivery = await deliveryService.update(req.params.id, input);
+      res.status(httpStatus.OK).json({
+        status: 'success',
+        data: delivery,
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async archive(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const userId = (req as AuthenticatedRequest).user?.id;
+      const delivery = await deliveryService.archive(req.params.id, userId);
+      res.status(httpStatus.OK).json({
+        status: 'success',
+        data: delivery,
+        message: 'Delivery archived successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async restore(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const delivery = await deliveryService.restore(req.params.id);
+      res.status(httpStatus.OK).json({
+        status: 'success',
+        data: delivery,
+        message: 'Delivery restored successfully',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async listArchived(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const page = req.query.page ? parseInt(req.query.page as string, 10) : 1;
+      const limit = req.query.limit ? parseInt(req.query.limit as string, 10) : 10;
+
+      const result = await deliveryService.listArchived(page, limit);
+      res.status(httpStatus.OK).json({
+        status: 'success',
+        data: result.data,
+        meta: {
+          total: result.total,
+          page: result.page,
+          limit: result.limit,
+          totalPages: result.totalPages,
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+export const deliveryController = new DeliveryController();

src/models/Delivery.ts

@@ -0,0 +1,210 @@
+import mongoose, { Document, Schema, Model, Query } from 'mongoose';
+import logger from '../config/logger';
+
+export enum DeliveryStatus {
+  PENDING = 'Pending',
+  ASSIGNED = 'Assigned',
+  PICKED_UP = 'Picked Up',
+  IN_TRANSIT = 'In Transit',
+  DELIVERED = 'Delivered',
+  CANCELLED = 'Cancelled',
+}
+
+export enum DeliverySize {
+  SMALL = 'Small',
+  MEDIUM = 'Medium',
+  LARGE = 'Large',
+  EXTRA_LARGE = 'Extra Large',
+}
+
+export interface ILocation {
+  address: string;
+  city: string;
+  state: string;
+  zipCode: string;
+  lat?: number;
+  lng?: number;
+  instructions?: string;
+}
+
+export interface IPackage {
+  description: string;
+  weight: number;
+  size: DeliverySize;
+  itemValue?: number;
+  isFragile: boolean;
+  requiresSignature: boolean;
+}
+
+export interface IDelivery extends Document {
+  trackingNumber: string;
+  customer: {
+    name: string;
+    phone: string;
+    email?: string;
+  };
+  pickup: ILocation;
+  dropoff: ILocation;
+  package: IPackage;
+  status: DeliveryStatus;
+  driver?: mongoose.Types.ObjectId;
+  estimatedDistance?: number;
+  estimatedDuration?: number;
+  deliveryFee: number;
+  escrowAmount: number;
+  stellarTransactionId?: string;
+  notes?: string;
+  isDeleted: boolean;
+  deletedAt: Date | null;
+  deletedBy?: mongoose.Types.ObjectId;
+  createdAt: Date;
+  updatedAt: Date;
+
+  softDelete(userId?: string): Promise<IDelivery>;
+  restore(): Promise<IDelivery>;
+}
+
+export interface IDeliveryModel extends Model<IDelivery> {
+  findAvailable(): Promise<IDelivery[]>;
+}
+
+const locationSchema = new Schema<ILocation>(
+  {
+    address: { type: String, required: true, trim: true },
+    city: { type: String, required: true, trim: true },
+    state: { type: String, required: true, trim: true },
+    zipCode: { type: String, required: true, trim: true },
+    lat: { type: Number },
+    lng: { type: Number },
+    instructions: { type: String, trim: true },
+  },
+  { _id: false },
+);
+
+const packageSchema = new Schema<IPackage>(
+  {
+    description: { type: String, required: true, trim: true },
+    weight: { type: Number, required: true, min: 0 },
+    size: { type: String, enum: Object.values(DeliverySize), required: true },
+    itemValue: { type: Number, min: 0 },
+    isFragile: { type: Boolean, default: false },
+    requiresSignature: { type: Boolean, default: false },
+  },
+  { _id: false },
+);
+
+const deliverySchema = new Schema<IDelivery, IDeliveryModel>(
+  {
+    trackingNumber: {
+      type: String,
+      required: true,
+      unique: true,
+      trim: true,
+      index: true,
+    },
+    customer: {
+      name: { type: String, required: true, trim: true },
+      phone: { type: String, required: true, trim: true },
+      email: { type: String, trim: true, lowercase: true },
+    },
+    pickup: { type: locationSchema, required: true },
+    dropoff: { type: locationSchema, required: true },
+    package: { type: packageSchema, required: true },
+    status: {
+      type: String,
+      enum: Object.values(DeliveryStatus),
+      default: DeliveryStatus.PENDING,
+      index: true,
+    },
+    driver: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+      index: true,
+    },
+    estimatedDistance: { type: Number, min: 0 },
+    estimatedDuration: { type: Number, min: 0 },
+    deliveryFee: { type: Number, required: true, min: 0 },
+    escrowAmount: { type: Number, required: true, min: 0 },
+    stellarTransactionId: { type: String, trim: true },
+    notes: { type: String, trim: true },
+    isDeleted: { type: Boolean, default: false, index: true },
+    deletedAt: { type: Date, default: null },
+    deletedBy: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+    },
+  },
+  {
+    timestamps: true,
+    toJSON: {
+      transform(_doc: unknown, ret: Record<string, unknown>): void {
+        delete ret.__v;
+      },
+    },
+  },
+);
+
+deliverySchema.pre<Query<IDelivery, IDelivery>>('find', function (next) {
+  if ((this.getOptions() as Record<string, unknown>).includeDeleted) {
+    return next();
+  }
+  this.where({ isDeleted: false });
+  next();
+});
+
+deliverySchema.pre<Query<IDelivery, IDelivery>>('findOne', function (next) {
+  if ((this.getOptions() as Record<string, unknown>).includeDeleted) {
+    return next();
+  }
+  this.where({ isDeleted: false });
+  next();
+});
+
+deliverySchema.pre<Query<IDelivery, IDelivery>>('findOneAndUpdate', function (next) {
+  if ((this.getOptions() as Record<string, unknown>).includeDeleted) {
+    return next();
+  }
+  this.where({ isDeleted: false });
+  next();
+});
+
+deliverySchema.pre<Query<IDelivery, IDelivery>>('countDocuments', function (next) {
+  if ((this.getOptions() as Record<string, unknown>).includeDeleted) {
+    return next();
+  }
+  this.where({ isDeleted: false });
+  next();
+});
+
+deliverySchema.methods.softDelete = async function (
+  this: IDelivery,
+  userId?: string,
+): Promise<IDelivery> {
+  this.isDeleted = true;
+  this.deletedAt = new Date();
+  if (userId) {
+    this.deletedBy = new mongoose.Types.ObjectId(userId);
+  }
+  logger.info(`Delivery ${this.trackingNumber} soft-deleted`);
+  return this.save();
+};
+
+deliverySchema.methods.restore = async function (this: IDelivery): Promise<IDelivery> {
+  this.isDeleted = false;
+  this.deletedAt = null;
+  this.deletedBy = undefined;
+  logger.info(`Delivery ${this.trackingNumber} restored`);
+  return this.save();
+};
+
+deliverySchema.statics.findAvailable = async function (): Promise<IDelivery[]> {
+  return this.find({ status: DeliveryStatus.PENDING, driver: null }).sort({ createdAt: -1 }).exec();
+};
+
+deliverySchema.index({ status: 1, isDeleted: 1 });
+deliverySchema.index({ 'customer.phone': 1 });
+deliverySchema.index({ createdAt: -1 });
+
+const Delivery = mongoose.model<IDelivery, IDeliveryModel>('Delivery', deliverySchema);
+
+export default Delivery;

src/routes/delivery.routes.ts

@@ -0,0 +1,14 @@
+import { Router } from 'express';
+import { deliveryController } from '../controllers/delivery.controller';
+
+const router = Router();
+
+router.post('/', deliveryController.create.bind(deliveryController));
+router.get('/', deliveryController.list.bind(deliveryController));
+router.get('/archived', deliveryController.listArchived.bind(deliveryController));
+router.get('/:id', deliveryController.getById.bind(deliveryController));
+router.patch('/:id', deliveryController.update.bind(deliveryController));
+router.patch('/:id/archive', deliveryController.archive.bind(deliveryController));
+router.patch('/:id/restore', deliveryController.restore.bind(deliveryController));
+
+export default router;

src/routes/index.ts

@@ -1,9 +1,8 @@
 import { Router } from 'express';
+import deliveryRoutes from './delivery.routes';
 
 const router = Router();
 
-// Define your routes here
-// router.use('/auth', authRoutes);
-// router.use('/users', userRoutes);
+router.use('/deliveries', deliveryRoutes);
 
 export default router;

src/server.ts

@@ -1,3 +1,7 @@
+import dotenv from 'dotenv';
+
+dotenv.config();
+
 import app from './app';
 import logger from './config/logger';