server-core-module 1.0.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "server-core-module",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "joi": "^18.0.2",
+    "mongodb": "^7.1.0",
+    "nodemailer": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.3.0",
+    "@types/nodemailer": "^7.0.11",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/controllers/order.controller.ts

@@ -0,0 +1,108 @@
+import { Request, Response, NextFunction } from "express";
+import { schemaOrder, schemaOrderUpdate } from "../models/order.model";
+import { useOrderRepository } from "../repositories/order.repository";
+import { BadRequestError } from "../error";
+import { sendOrderConfirmation, sendOrderStatusUpdate, sendAdminNotification } from "../utils/email.service";
+import dotenv from "dotenv"; 
+dotenv.config();
+
+
+export function useOrderController() {
+
+    const {
+        getAll: _getAll,
+        add: _add,
+        getById: _getById,
+        deleteById: _deleteById,
+        updateById: _updateById
+    } = useOrderRepository();
+
+    async function add(req: Request, res: Response, next: NextFunction) {
+        const value = req.body;
+        const { error } = schemaOrder.validate(value);
+
+    if(error) {
+        next(new BadRequestError(error.details[0].message));
+        return;
+    }
+    try {
+        const message = await _add(value);
+        // ← dagdag mo dito
+        await sendOrderConfirmation(value.email, value.name, value.items, value.totalAmount, value.deliveryFee);     
+        await sendAdminNotification(value.name, value.items, value.totalAmount, value.email, value.deliveryFee);  
+        res.json({message});
+    } catch (error) {
+        next(error);
+    }
+}
+    
+        async function getAll(req: Request, res: Response, next: NextFunction) {
+            try {
+                const status = req.query.status as string | undefined;
+                const page = Number(req.query.page) || 1;
+                const limit = Number(req.query.limit) || 10;
+                const items = await _getAll({status, page, limit});
+                res.json(items);
+            } catch (error) {
+                next(error);
+            }
+        }
+    
+        async function getById(req: Request, res: Response, next: NextFunction) {
+            const id = req.params.id as string;
+            try {
+                const item = await _getById(id);
+                res.json(item);
+            } catch (error) {
+                next(error);
+            }
+        }
+    
+        async function updateById(req: Request, res: Response, next: NextFunction) {
+                    try {
+                        const id = req.params.id as string;
+                        const value = req.body;
+                        const { error } = schemaOrderUpdate.validate(value);
+
+                        if(error) {
+                            next(new BadRequestError(error.message));
+                            return;
+                        }
+
+                        await _updateById(id, value);
+                        
+                        // fetch yung order para makuha email at name
+                        const order = await _getById(id);
+                        if(!order){
+                            res.status(404).json({message: "Order not found"});
+                            return;
+                        }
+
+                        if(value.status) {
+                            await sendOrderStatusUpdate(order.email as string, order.name as string, value.status);
+                        }
+
+                        res.json({message: "Order updated successfully", order});
+                    } catch (error) {
+                        next(error);
+                    }
+                }
+    
+        async function deleteById(req: Request, res: Response, next: NextFunction) {
+            try {
+                const id = req.params.id as string;
+                await _deleteById(id);
+                res.json({message: "Order deleted successfully"});
+            } catch (error) {
+                next(error);
+            }
+        }
+      
+        return{
+            add,
+            getAll,
+            getById,
+            updateById,
+            deleteById,
+        };
+}

package/src/controllers/product.controller.ts

@@ -0,0 +1,94 @@
+import { Request, Response, NextFunction } from 'express';
+import { schemaProduct, schemaProductUpdate } from '../models/product.model';
+import { useProductRepository } from '../repositories/product.repository';
+import { BadRequestError } from '../error';
+
+export function useProductController() {
+  
+    const {
+         getAll: _getAll,
+         add: _add,
+         getById: _getById,
+         deleteById: _deleteById,
+         updateById: _updateById
+    } = useProductRepository();
+
+    async function add(req: Request, res: Response, next: NextFunction) {
+        const value = req.body;
+        const { error } = schemaProduct.validate(value);
+
+        if(error) {
+            next(new BadRequestError(error.details[0].message));
+            return;
+        }
+        try {
+            const message = await _add(value);
+            res.json({message});
+        } catch (error) {
+            next(error);
+        }
+    }
+
+    async function getAll(req: Request, res: Response, next: NextFunction) {
+        try {
+            const category = req.query.category as string | undefined;
+            const page = Number(req.query.page) || 1;
+            const limit = Number(req.query.limit) || 10;
+            const items = await _getAll({category, page, limit});
+            res.json(items);
+        } catch (error) {
+            next(error);
+        }
+    }
+
+    async function getById(req: Request, res: Response, next: NextFunction) {
+        const id = req.params.id as string;
+        try {
+            const item = await _getById(id);
+            res.json(item);
+        } catch (error) {
+            next(error);
+        }
+    }
+
+    async function updateById(req: Request, res: Response, next: NextFunction) {
+        try {
+        const id = req.params.id as string;
+        const value = req.body;
+        const { error } = schemaProductUpdate.validate(value);
+
+        if(error) {
+            next(new BadRequestError(error.message));
+            return;
+        }
+
+        const updated = await _updateById(id, value);
+        if(!updated){
+            res.status(404).json({message: "Product not found"});
+            return;
+        }
+
+        res.json({message: "Product updated successfully", updated});
+        } catch (error) {
+            next(error);
+        }
+    }
+
+    async function deleteById(req: Request, res: Response, next: NextFunction) {
+        try {
+            const id = req.params.id as string;
+            await _deleteById(id);
+            res.json({message: "Product deleted successfully"});
+        } catch (error) {
+            next(error);
+        }
+    }
+  
+    return{
+        add,
+        getAll,
+        getById,
+        updateById,
+        deleteById,
+    }
+}

package/src/error.ts

@@ -0,0 +1,37 @@
+
+export class AppError extends Error {
+    public readonly statusCode: number;
+    public readonly isOperational: boolean;
+
+    constructor(message: string, statusCode: number, isOperational: boolean = true){
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.statusCode = statusCode;
+        this.isOperational = isOperational;
+        Error.captureStackTrace(this);
+    }
+}
+
+export class BadRequestError extends AppError {
+    constructor(message: string = 'Bad Request'){
+        super(message, 400);
+    }
+}
+
+export class Unauthorized extends AppError {
+    constructor(message: string = 'Unauthorized'){
+        super(message, 401);
+    }
+}
+
+export class NotFoundError extends AppError {
+    constructor(message: string = 'Not Found'){
+        super(message, 404);
+    }
+}
+
+export class InternalServerError extends AppError {
+    constructor(message: string = 'Internal Server Error'){
+        super(message, 500);
+    }
+}

package/src/models/order.model.ts

@@ -0,0 +1,72 @@
+ import Joi from 'joi';
+import { ObjectId } from 'mongodb';
+
+export type TOrder = {
+    _id?: ObjectId;
+    name: string;
+    email: string;
+    phone: string;
+    address: string;
+     items: {
+        productId: string;
+        name: string;
+        price: number;
+        quantity: number;
+    }[];
+    totalAmount: number;
+    note?: string;
+    deliveryDate?: Date;
+    status?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    location?: string;
+    deliveryFee?: number;
+};
+
+export const schemaOrder = Joi.object({
+    name: Joi.string().required(),
+    email: Joi.string().email().required(),
+    phone: Joi.string().required(),
+    address: Joi.string().required(),
+    items: Joi.array().items(Joi.object({
+        productId: Joi.string().required(),
+        name: Joi.string().required(),
+        price: Joi.number().min(0).required(),
+        quantity: Joi.number().min(1).required(),
+    })).required(),
+    totalAmount: Joi.number().min(0).required(),
+    note: Joi.string().optional(),
+    deliveryDate: Joi.date().optional(),
+    status: Joi.string().default("pending"),
+    location: Joi.string().optional(),
+    deliveryFee: Joi.number().min(0).optional(),
+});
+
+
+export const schemaOrderUpdate = Joi.object({
+    name: Joi.string(),
+    email: Joi.string().email(),
+    phone: Joi.string(),
+    address: Joi.string(),  
+    items: Joi.array().items(Joi.object({
+        productId: Joi.string().required(),
+        name: Joi.string().required(),
+        price: Joi.number().min(0).required(),
+        quantity: Joi.number().min(1).required(),
+    })),
+    totalAmount: Joi.number().min(0),
+    note: Joi.string(),
+    deliveryDate: Joi.date(),
+    status: Joi.string(), 
+    location: Joi.string(),
+    deliveryFee: Joi.number().min(0),
+});
+ 
+export function modelOrder(value: TOrder): TOrder {
+    return {
+        ...value,
+        status: value.status || "pending",
+        createdAt: value.createdAt || new Date(),
+        updatedAt: new Date(),
+    };
+}

package/src/models/product.model.ts

@@ -0,0 +1,42 @@
+import Joi from 'joi';
+import { ObjectId } from 'mongodb';
+
+export type TProduct = {
+  _id?: ObjectId;
+  name: string;
+  description: string;
+  price: number;
+  imageUrl?: string;
+  status?:string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  category?: string;
+ };
+
+ export const schemaProduct = Joi.object({
+
+  name: Joi.string().required(),
+  description: Joi.string().required(),
+  price: Joi.number().min(0).required(),
+  imageUrl: Joi.string().optional(),
+  status: Joi.string().default("available"),
+  category: Joi.string().optional(),
+ });
+
+  export const schemaProductUpdate = Joi.object({
+
+  name: Joi.string(),
+  description: Joi.string(),
+  price: Joi.number().min(0),
+  imageUrl: Joi.string(),
+  status: Joi.string(), 
+  category: Joi.string(),  
+ });
+
+ export function modelProduct(value: TProduct): TProduct {
+    return {
+        ...value,
+        createdAt: value.createdAt || new Date(),
+        updatedAt: new Date(),
+    };
+ }

package/src/repositories/order.repository.ts

@@ -0,0 +1,123 @@
+import { Collection, ObjectId, Db    } from "mongodb";
+import { TOrder, modelOrder  } from "../models/order.model";
+import { paginate } from "../utils/paginate.util";
+
+let db: Db;
+
+export function setDb(database: Db) {
+    db = database;
+}
+
+export function useOrderRepository(){
+  const collection = db.collection('orders');
+
+  //CREATE INDEXES
+
+  async function createIndexes() {
+    try {
+        await collection.createIndexes([
+            { key: { name:1}},
+            { key: { createdAt:1}},
+        ]);
+        return "Indexes created successfully";
+    } catch (error: any) {
+        throw new Error(`Error creating indexes: ${error.message}`);
+    }
+  }
+
+  //ADD ORDER
+
+  async function add(value: TOrder){
+    try {
+        value = modelOrder(value);
+        const result = await collection.insertOne(value);
+        return result.insertedId;
+    } catch (error: any) {
+        throw new Error(`Error adding order: ${error.message}`);
+    }
+  }
+
+  //GET ALL ORDERS
+
+   async function getAll({
+    page = 1,
+    limit = 10,
+    status = "",
+} = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query: any = {};
+    if (status) query.status = status;
+
+    try {
+        const items = await collection.aggregate([
+            { $match: query },
+            { $skip: page * limit },
+            { $limit: limit },
+        ]).toArray();
+
+        const length = await collection.countDocuments(query);
+        return paginate(items, page, limit, length);
+    } catch (error: any) {
+        throw new Error("Failed to get orders: " + error.message);
+    }
+}
+
+    //GET ORDER BY ID
+
+    async function getById(id: string) {
+        try {
+            const item =await collection.findOne({_id: new ObjectId(id)});
+            return item;
+        } catch (error) {
+            throw new Error("Failed to get order: " + error);
+        }
+    }
+
+    //UPDATE BY ID
+
+    async function updateById(id:string, value: Partial<TOrder>){
+
+          try {
+                new ObjectId(id);  
+            } catch (error) {
+                throw new Error("Invalid ID format");
+            }
+
+          try {
+            value.updatedAt = new Date();
+            const result = await collection.updateOne( 
+                {_id: new ObjectId(id)},
+                { $set: value }
+            );
+            return result.modifiedCount;
+        } catch (error:any) {
+          throw new Error("Failed to update order:" + error.message)
+        }
+    }
+
+    //DELETE BY ID
+
+    async function deleteById(id: string){
+        try {
+            id= new ObjectId(id) as any;
+        } catch (error) {
+            throw new Error("Failed to delete order: " + error);
+        }
+
+        try {
+            await collection.deleteOne({_id: id as any});
+            return "Order deleted successfully";
+        } catch (error: any) {
+            throw new Error("Failed to delete order: " + error.message);
+        }
+    }
+
+    return {
+        add,
+        getAll,
+        getById,
+        updateById,
+        deleteById,
+    }
+}
+ 

package/src/repositories/product.repository.ts

@@ -0,0 +1,124 @@
+import { Collection, ObjectId, Db    } from "mongodb";
+import { TProduct, modelProduct  } from "../models/product.model";
+import { paginate } from "../utils/paginate.util";
+
+
+let db: Db;
+
+export function setDb(database: Db) {
+    db = database;
+}
+
+export function useProductRepository(){
+  const collection = db.collection('products');
+
+  //CREATE INDEXES
+
+  async function createIndexes() {
+    try {
+        await collection.createIndexes([
+            { key: { name:1}},
+            { key: { createdAt:1}},
+        ]);
+        return "Indexes created successfully";
+    } catch (error: any) {
+        throw new Error(`Error creating indexes: ${error.message}`);
+    }
+  }
+
+  //ADD PRODUCT
+
+  async function add(value: TProduct){
+    try {
+        value = modelProduct(value);
+        const result = await collection.insertOne(value);
+        return result.insertedId;
+    } catch (error: any) {
+        throw new Error(`Error adding product: ${error.message}`);
+    }
+  }
+
+  //GET ALL PRODUCTS
+
+   async function getAll({
+    page = 1,
+    limit = 10,
+    category = "",
+} = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query: any = {};
+    if (category) query.category = category;
+
+    try {
+        const items = await collection.aggregate([
+            { $match: query },
+            { $skip: page * limit },
+            { $limit: limit },
+        ]).toArray();
+
+        const length = await collection.countDocuments(query);
+        return paginate(items, page, limit, length);
+    } catch (error: any) {
+        throw new Error("Failed to get products: " + error.message);
+    }
+}
+
+    //GET PRODUCT BY ID
+
+    async function getById(id: string) {
+        try {
+            const item =await collection.findOne({_id: new ObjectId(id)});
+            return item;
+        } catch (error) {
+            throw new Error("Failed to get product: " + error);
+        }
+    }
+
+    //UPDATE BY ID
+
+    async function updateById(id:string, value: Partial<TProduct>){
+
+          try {
+                new ObjectId(id);  
+            } catch (error) {
+                throw new Error("Invalid ID format");
+            }
+
+          try {
+            value.updatedAt = new Date();
+            const result = await collection.updateOne( 
+                {_id: new ObjectId(id)},
+                { $set: value }
+            );
+            return result.modifiedCount;
+        } catch (error:any) {
+          throw new Error("Failed to update item:" + error.message)
+        }
+    }
+
+    //DELETE BY ID
+
+    async function deleteById(id: string){
+        try {
+            id= new ObjectId(id) as any;
+        } catch (error) {
+            throw new Error("Failed to delete product: " + error);
+        }
+
+        try {
+            await collection.deleteOne({_id: id as any});
+            return "Product deleted successfully";
+        } catch (error: any) {
+            throw new Error("Failed to delete product: " + error.message);
+        }
+    }
+
+    return {
+        add,
+        getAll,
+        getById,
+        updateById,
+        deleteById,
+    }
+}
+ 

package/src/utils/email.service.ts

@@ -0,0 +1,165 @@
+import nodemailer from "nodemailer";
+
+function createTransporter() {
+    return nodemailer.createTransport({
+        service: "gmail",
+        auth: {
+            user: process.env.EMAIL_USER,
+            pass: process.env.EMAIL_PASS,
+        },
+    });
+}
+
+export async function sendOrderConfirmation(email: string, name: string, items: any[], totalAmount: number, deliveryFee?: number) {
+    console.log("Sending email to:", email);
+    try {
+        const transporter = createTransporter();
+
+        const itemsList = items.map(item => 
+            `<tr>
+                <td>${item.name}</td>
+                <td>${item.quantity}</td>
+                <td>₱${item.price}</td>
+                <td>₱${item.price * item.quantity}</td>
+            </tr>`
+        ).join("");
+
+        await transporter.sendMail({
+            from: `"Cesar's Flower Shop 🌸" <${process.env.EMAIL_USER}>`,
+            to: email,
+            subject: "Order Received! 🌸",
+            html: `
+                    <h2>Hi ${name}!</h2>
+                    <p>Your order has been received! 🌸</p>
+                    <table border="1" cellpadding="8" cellspacing="0" style="border-collapse: collapse;">
+                        <tr>
+                            <th>Item</th>
+                            <th>Qty</th>
+                            <th>Price</th>
+                            <th>Subtotal</th>
+                        </tr>
+                        ${itemsList}
+                    </table>
+                    <h3>Items Subtotal: ₱${totalAmount - (deliveryFee || 0)}</h3>
+                    <h3>Delivery Fee: ₱${deliveryFee || 0}</h3>
+                    <h3>Total: ₱${totalAmount}</h3>
+                    <p>We will confirm your order soon.</p>
+                    <p>Thank you for ordering from Cesar's Flower Shop!</p>
+                `,
+        });
+        console.log("Email sent successfully!");
+    } catch (error) {
+        console.error("Email error:", error);
+    }
+}
+
+export async function sendOrderStatusUpdate(email: string, name: string, status: string) {
+    try {
+        const transporter = createTransporter();
+        await transporter.sendMail({
+            from: `"Cesar's Flower Shop 🌸" <${process.env.EMAIL_USER}>`,
+            to: email,
+            subject: `Order ${status}! 🌸`,
+            html: `
+                <h2>Hi ${name}!</h2>
+                <p>Your order is now <strong>${status}</strong>! 🌸</p>
+                <br/>
+                <p>Thank you for ordering from Cesar's Flower Shop!</p>
+            `,
+        });
+        console.log("Status email sent!");
+    } catch (error) {
+        console.error("Status email error:", error);
+    }
+}
+
+export async function sendAdminNotification(name: string, items: any[], totalAmount: number, customerEmail: string, deliveryFee?:number) {
+    try {
+        const transporter = createTransporter();
+
+        const itemsList = items.map(item => 
+            `<tr>
+                <td>${item.name}</td>
+                <td>${item.quantity}</td>
+                <td>₱${item.price}</td>
+                <td>₱${item.price * item.quantity}</td>
+            </tr>`
+        ).join("");
+
+        await transporter.sendMail({
+            from: `"Cesar's Flower Shop 🌸" <${process.env.EMAIL_USER}>`,
+            to: process.env.EMAIL_USER,
+            subject: `New Order from ${name}! 🌸`,
+            html: `
+                    <h2>New Order Received! 🌸</h2>
+                    <p><strong>Customer:</strong> ${name}</p>
+                    <p><strong>Email:</strong> ${customerEmail}</p>
+                    <table border="1" cellpadding="8" cellspacing="0">
+                        <tr>
+                            <th>Item</th>
+                            <th>Qty</th>
+                            <th>Price</th>
+                            <th>Subtotal</th>
+                        </tr>
+                        ${itemsList}
+                        <tr>
+                            <td colspan="3"><strong>Items Subtotal</strong></td>
+                            <td>₱${totalAmount - (deliveryFee || 0)}</td>
+                        </tr>
+                        <tr>
+                            <td colspan="3"><strong>Delivery Fee</strong></td>
+                            <td>₱${deliveryFee || 0}</td>
+                        </tr>
+                        <tr>
+                            <td colspan="3"><strong>Total</strong></td>
+                            <td><strong>₱${totalAmount}</strong></td>
+                        </tr>
+                    </table>
+                    <p>Login to admin panel to confirm the order!</p>
+                `,
+        });
+        console.log("Admin notified!");
+    } catch (error) {
+        console.error("Admin email error:", error);
+    }
+}
+
+export async function sendContactEmail(name: string, email: string, phone: string, eventType: string, message: string) {
+    try {
+        const transporter = createTransporter();
+
+        await transporter.sendMail({
+            from: `"Cesar's Flower Shop 🌸" <${process.env.EMAIL_USER}>`,
+            to: process.env.EMAIL_USER,
+            subject: `New Inquiry from ${name} - ${eventType} 🌸`,
+            html: `
+                <h2>New Customer Inquiry! 🌸</h2>
+                <p><strong>Name:</strong> ${name}</p>
+                <p><strong>Email:</strong> ${email}</p>
+                <p><strong>Phone:</strong> ${phone}</p>
+                <p><strong>Event Type:</strong> ${eventType}</p>
+                <p><strong>Message:</strong></p>
+                <p>${message}</p>
+            `,
+        });
+
+        await transporter.sendMail({
+            from: `"Cesar's Flower Shop 🌸" <${process.env.EMAIL_USER}>`,
+            to: email,
+            subject: `We received your message! 🌸`,
+            html: `
+                <h2>Hi ${name}! 🌸</h2>
+                <p>Thank you for reaching out to Cesar's Flower Shop!</p>
+                <p>We have received your inquiry about <strong>${eventType}</strong>.</p>
+                <p>We will get back to you as soon as possible.</p>
+                <br/>
+                <p>Thank you for choosing Cesar's Flower Shop! 🌺</p>
+            `,
+        });
+
+        console.log("Contact email sent!");
+    } catch (error) {
+        console.error("Contact email error:", error);
+    }
+}
+

package/src/utils/paginate.util.ts

@@ -0,0 +1,19 @@
+export function paginate(
+    items: any[],
+    page: number,
+    limit: number,
+    length: number
+) {
+    if (length === 0) {
+        return { items: [], totalPages: 0, currentPage: 0 };
+    }
+
+    const startIndex = page * limit + 1;
+    const endIndex = Math.min(startIndex + limit - 1, length);
+
+    return {
+        items,
+        pages: Math.ceil(length / limit),
+        pageRange: `${startIndex}-${endIndex} of ${length}`,
+    };
+}