server-core-module 1.0.0 → 1.0.1

package/dist/controllers/order.controller.d.ts

@@ -0,0 +1,8 @@
+import { Request, Response, NextFunction } from "express";
+export declare function useOrderController(): {
+    add: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAll: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    updateById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    deleteById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};

package/dist/controllers/order.controller.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOrderController = useOrderController;
+const order_model_1 = require("../models/order.model");
+const order_repository_1 = require("../repositories/order.repository");
+const error_1 = require("../error");
+const email_service_1 = require("../utils/email.service");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+function useOrderController() {
+    const { getAll: _getAll, add: _add, getById: _getById, deleteById: _deleteById, updateById: _updateById } = (0, order_repository_1.useOrderRepository)();
+    async function add(req, res, next) {
+        const value = req.body;
+        const { error } = order_model_1.schemaOrder.validate(value);
+        if (error) {
+            next(new error_1.BadRequestError(error.details[0].message));
+            return;
+        }
+        try {
+            const message = await _add(value);
+            // ← dagdag mo dito
+            await (0, email_service_1.sendOrderConfirmation)(value.email, value.name, value.items, value.totalAmount, value.deliveryFee);
+            await (0, email_service_1.sendAdminNotification)(value.name, value.items, value.totalAmount, value.email, value.deliveryFee);
+            res.json({ message });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    async function getAll(req, res, next) {
+        try {
+            const status = req.query.status;
+            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, res, next) {
+        const id = req.params.id;
+        try {
+            const item = await _getById(id);
+            res.json(item);
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    async function updateById(req, res, next) {
+        try {
+            const id = req.params.id;
+            const value = req.body;
+            const { error } = order_model_1.schemaOrderUpdate.validate(value);
+            if (error) {
+                next(new error_1.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 (0, email_service_1.sendOrderStatusUpdate)(order.email, order.name, value.status);
+            }
+            res.json({ message: "Order updated successfully", order });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    async function deleteById(req, res, next) {
+        try {
+            const id = req.params.id;
+            await _deleteById(id);
+            res.json({ message: "Order deleted successfully" });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    return {
+        add,
+        getAll,
+        getById,
+        updateById,
+        deleteById,
+    };
+}

package/dist/controllers/product.controller.d.ts

@@ -0,0 +1,8 @@
+import { Request, Response, NextFunction } from 'express';
+export declare function useProductController(): {
+    add: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAll: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    updateById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    deleteById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};

package/dist/controllers/product.controller.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProductController = useProductController;
+const product_model_1 = require("../models/product.model");
+const product_repository_1 = require("../repositories/product.repository");
+const error_1 = require("../error");
+function useProductController() {
+    const { getAll: _getAll, add: _add, getById: _getById, deleteById: _deleteById, updateById: _updateById } = (0, product_repository_1.useProductRepository)();
+    async function add(req, res, next) {
+        const value = req.body;
+        const { error } = product_model_1.schemaProduct.validate(value);
+        if (error) {
+            next(new error_1.BadRequestError(error.details[0].message));
+            return;
+        }
+        try {
+            const message = await _add(value);
+            res.json({ message });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    async function getAll(req, res, next) {
+        try {
+            const category = req.query.category;
+            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, res, next) {
+        const id = req.params.id;
+        try {
+            const item = await _getById(id);
+            res.json(item);
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    async function updateById(req, res, next) {
+        try {
+            const id = req.params.id;
+            const value = req.body;
+            const { error } = product_model_1.schemaProductUpdate.validate(value);
+            if (error) {
+                next(new error_1.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, res, next) {
+        try {
+            const id = req.params.id;
+            await _deleteById(id);
+            res.json({ message: "Product deleted successfully" });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    return {
+        add,
+        getAll,
+        getById,
+        updateById,
+        deleteById,
+    };
+}

package/dist/error.d.ts

@@ -0,0 +1,17 @@
+export declare class AppError extends Error {
+    readonly statusCode: number;
+    readonly isOperational: boolean;
+    constructor(message: string, statusCode: number, isOperational?: boolean);
+}
+export declare class BadRequestError extends AppError {
+    constructor(message?: string);
+}
+export declare class Unauthorized extends AppError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends AppError {
+    constructor(message?: string);
+}
+export declare class InternalServerError extends AppError {
+    constructor(message?: string);
+}

package/dist/error.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerError = exports.NotFoundError = exports.Unauthorized = exports.BadRequestError = exports.AppError = void 0;
+class AppError extends Error {
+    constructor(message, statusCode, isOperational = true) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.statusCode = statusCode;
+        this.isOperational = isOperational;
+        Error.captureStackTrace(this);
+    }
+}
+exports.AppError = AppError;
+class BadRequestError extends AppError {
+    constructor(message = 'Bad Request') {
+        super(message, 400);
+    }
+}
+exports.BadRequestError = BadRequestError;
+class Unauthorized extends AppError {
+    constructor(message = 'Unauthorized') {
+        super(message, 401);
+    }
+}
+exports.Unauthorized = Unauthorized;
+class NotFoundError extends AppError {
+    constructor(message = 'Not Found') {
+        super(message, 404);
+    }
+}
+exports.NotFoundError = NotFoundError;
+class InternalServerError extends AppError {
+    constructor(message = 'Internal Server Error') {
+        super(message, 500);
+    }
+}
+exports.InternalServerError = InternalServerError;

package/dist/models/order.model.d.ts

@@ -0,0 +1,26 @@
+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 declare const schemaOrder: Joi.ObjectSchema<any>;
+export declare const schemaOrderUpdate: Joi.ObjectSchema<any>;
+export declare function modelOrder(value: TOrder): TOrder;

package/dist/models/order.model.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaOrderUpdate = exports.schemaOrder = void 0;
+exports.modelOrder = modelOrder;
+const joi_1 = __importDefault(require("joi"));
+exports.schemaOrder = joi_1.default.object({
+    name: joi_1.default.string().required(),
+    email: joi_1.default.string().email().required(),
+    phone: joi_1.default.string().required(),
+    address: joi_1.default.string().required(),
+    items: joi_1.default.array().items(joi_1.default.object({
+        productId: joi_1.default.string().required(),
+        name: joi_1.default.string().required(),
+        price: joi_1.default.number().min(0).required(),
+        quantity: joi_1.default.number().min(1).required(),
+    })).required(),
+    totalAmount: joi_1.default.number().min(0).required(),
+    note: joi_1.default.string().optional(),
+    deliveryDate: joi_1.default.date().optional(),
+    status: joi_1.default.string().default("pending"),
+    location: joi_1.default.string().optional(),
+    deliveryFee: joi_1.default.number().min(0).optional(),
+});
+exports.schemaOrderUpdate = joi_1.default.object({
+    name: joi_1.default.string(),
+    email: joi_1.default.string().email(),
+    phone: joi_1.default.string(),
+    address: joi_1.default.string(),
+    items: joi_1.default.array().items(joi_1.default.object({
+        productId: joi_1.default.string().required(),
+        name: joi_1.default.string().required(),
+        price: joi_1.default.number().min(0).required(),
+        quantity: joi_1.default.number().min(1).required(),
+    })),
+    totalAmount: joi_1.default.number().min(0),
+    note: joi_1.default.string(),
+    deliveryDate: joi_1.default.date(),
+    status: joi_1.default.string(),
+    location: joi_1.default.string(),
+    deliveryFee: joi_1.default.number().min(0),
+});
+function modelOrder(value) {
+    return {
+        ...value,
+        status: value.status || "pending",
+        createdAt: value.createdAt || new Date(),
+        updatedAt: new Date(),
+    };
+}

package/dist/models/product.model.d.ts

@@ -0,0 +1,16 @@
+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 declare const schemaProduct: Joi.ObjectSchema<any>;
+export declare const schemaProductUpdate: Joi.ObjectSchema<any>;
+export declare function modelProduct(value: TProduct): TProduct;

package/dist/models/product.model.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaProductUpdate = exports.schemaProduct = void 0;
+exports.modelProduct = modelProduct;
+const joi_1 = __importDefault(require("joi"));
+exports.schemaProduct = joi_1.default.object({
+    name: joi_1.default.string().required(),
+    description: joi_1.default.string().required(),
+    price: joi_1.default.number().min(0).required(),
+    imageUrl: joi_1.default.string().optional(),
+    status: joi_1.default.string().default("available"),
+    category: joi_1.default.string().optional(),
+});
+exports.schemaProductUpdate = joi_1.default.object({
+    name: joi_1.default.string(),
+    description: joi_1.default.string(),
+    price: joi_1.default.number().min(0),
+    imageUrl: joi_1.default.string(),
+    status: joi_1.default.string(),
+    category: joi_1.default.string(),
+});
+function modelProduct(value) {
+    return {
+        ...value,
+        createdAt: value.createdAt || new Date(),
+        updatedAt: new Date(),
+    };
+}

package/dist/repositories/order.repository.d.ts

@@ -0,0 +1,26 @@
+import { ObjectId, Db } from "mongodb";
+import { TOrder } from "../models/order.model";
+export declare function setDb(database: Db): void;
+export declare function useOrderRepository(): {
+    add: (value: TOrder) => Promise<ObjectId>;
+    getAll: ({ page, limit, status, }?: {
+        page?: number;
+        limit?: number;
+        status?: string;
+    }) => Promise<{
+        items: any[];
+        totalPages: number;
+        currentPage: number;
+        pages?: undefined;
+        pageRange?: undefined;
+    } | {
+        items: any[];
+        pages: number;
+        pageRange: string;
+        totalPages?: undefined;
+        currentPage?: undefined;
+    }>;
+    getById: (id: string) => Promise<import("mongodb").WithId<import("bson").Document>>;
+    updateById: (id: string, value: Partial<TOrder>) => Promise<number>;
+    deleteById: (id: string) => Promise<string>;
+};

package/dist/repositories/order.repository.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDb = setDb;
+exports.useOrderRepository = useOrderRepository;
+const mongodb_1 = require("mongodb");
+const order_model_1 = require("../models/order.model");
+const paginate_util_1 = require("../utils/paginate.util");
+let db;
+function setDb(database) {
+    db = database;
+}
+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) {
+            throw new Error(`Error creating indexes: ${error.message}`);
+        }
+    }
+    //ADD ORDER
+    async function add(value) {
+        try {
+            value = (0, order_model_1.modelOrder)(value);
+            const result = await collection.insertOne(value);
+            return result.insertedId;
+        }
+        catch (error) {
+            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 = {};
+        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 (0, paginate_util_1.paginate)(items, page, limit, length);
+        }
+        catch (error) {
+            throw new Error("Failed to get orders: " + error.message);
+        }
+    }
+    //GET ORDER BY ID
+    async function getById(id) {
+        try {
+            const item = await collection.findOne({ _id: new mongodb_1.ObjectId(id) });
+            return item;
+        }
+        catch (error) {
+            throw new Error("Failed to get order: " + error);
+        }
+    }
+    //UPDATE BY ID
+    async function updateById(id, value) {
+        try {
+            new mongodb_1.ObjectId(id);
+        }
+        catch (error) {
+            throw new Error("Invalid ID format");
+        }
+        try {
+            value.updatedAt = new Date();
+            const result = await collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, { $set: value });
+            return result.modifiedCount;
+        }
+        catch (error) {
+            throw new Error("Failed to update order:" + error.message);
+        }
+    }
+    //DELETE BY ID
+    async function deleteById(id) {
+        try {
+            id = new mongodb_1.ObjectId(id);
+        }
+        catch (error) {
+            throw new Error("Failed to delete order: " + error);
+        }
+        try {
+            await collection.deleteOne({ _id: id });
+            return "Order deleted successfully";
+        }
+        catch (error) {
+            throw new Error("Failed to delete order: " + error.message);
+        }
+    }
+    return {
+        add,
+        getAll,
+        getById,
+        updateById,
+        deleteById,
+    };
+}

package/dist/repositories/product.repository.d.ts

@@ -0,0 +1,26 @@
+import { ObjectId, Db } from "mongodb";
+import { TProduct } from "../models/product.model";
+export declare function setDb(database: Db): void;
+export declare function useProductRepository(): {
+    add: (value: TProduct) => Promise<ObjectId>;
+    getAll: ({ page, limit, category, }?: {
+        page?: number;
+        limit?: number;
+        category?: string;
+    }) => Promise<{
+        items: any[];
+        totalPages: number;
+        currentPage: number;
+        pages?: undefined;
+        pageRange?: undefined;
+    } | {
+        items: any[];
+        pages: number;
+        pageRange: string;
+        totalPages?: undefined;
+        currentPage?: undefined;
+    }>;
+    getById: (id: string) => Promise<import("mongodb").WithId<import("bson").Document>>;
+    updateById: (id: string, value: Partial<TProduct>) => Promise<number>;
+    deleteById: (id: string) => Promise<string>;
+};

package/dist/repositories/product.repository.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDb = setDb;
+exports.useProductRepository = useProductRepository;
+const mongodb_1 = require("mongodb");
+const product_model_1 = require("../models/product.model");
+const paginate_util_1 = require("../utils/paginate.util");
+let db;
+function setDb(database) {
+    db = database;
+}
+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) {
+            throw new Error(`Error creating indexes: ${error.message}`);
+        }
+    }
+    //ADD PRODUCT
+    async function add(value) {
+        try {
+            value = (0, product_model_1.modelProduct)(value);
+            const result = await collection.insertOne(value);
+            return result.insertedId;
+        }
+        catch (error) {
+            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 = {};
+        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 (0, paginate_util_1.paginate)(items, page, limit, length);
+        }
+        catch (error) {
+            throw new Error("Failed to get products: " + error.message);
+        }
+    }
+    //GET PRODUCT BY ID
+    async function getById(id) {
+        try {
+            const item = await collection.findOne({ _id: new mongodb_1.ObjectId(id) });
+            return item;
+        }
+        catch (error) {
+            throw new Error("Failed to get product: " + error);
+        }
+    }
+    //UPDATE BY ID
+    async function updateById(id, value) {
+        try {
+            new mongodb_1.ObjectId(id);
+        }
+        catch (error) {
+            throw new Error("Invalid ID format");
+        }
+        try {
+            value.updatedAt = new Date();
+            const result = await collection.updateOne({ _id: new mongodb_1.ObjectId(id) }, { $set: value });
+            return result.modifiedCount;
+        }
+        catch (error) {
+            throw new Error("Failed to update item:" + error.message);
+        }
+    }
+    //DELETE BY ID
+    async function deleteById(id) {
+        try {
+            id = new mongodb_1.ObjectId(id);
+        }
+        catch (error) {
+            throw new Error("Failed to delete product: " + error);
+        }
+        try {
+            await collection.deleteOne({ _id: id });
+            return "Product deleted successfully";
+        }
+        catch (error) {
+            throw new Error("Failed to delete product: " + error.message);
+        }
+    }
+    return {
+        add,
+        getAll,
+        getById,
+        updateById,
+        deleteById,
+    };
+}

package/dist/utils/email.service.d.ts

@@ -0,0 +1,4 @@
+export declare function sendOrderConfirmation(email: string, name: string, items: any[], totalAmount: number, deliveryFee?: number): Promise<void>;
+export declare function sendOrderStatusUpdate(email: string, name: string, status: string): Promise<void>;
+export declare function sendAdminNotification(name: string, items: any[], totalAmount: number, customerEmail: string, deliveryFee?: number): Promise<void>;
+export declare function sendContactEmail(name: string, email: string, phone: string, eventType: string, message: string): Promise<void>;

package/dist/utils/email.service.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendOrderConfirmation = sendOrderConfirmation;
+exports.sendOrderStatusUpdate = sendOrderStatusUpdate;
+exports.sendAdminNotification = sendAdminNotification;
+exports.sendContactEmail = sendContactEmail;
+const nodemailer_1 = __importDefault(require("nodemailer"));
+function createTransporter() {
+    return nodemailer_1.default.createTransport({
+        service: "gmail",
+        auth: {
+            user: process.env.EMAIL_USER,
+            pass: process.env.EMAIL_PASS,
+        },
+    });
+}
+async function sendOrderConfirmation(email, name, items, totalAmount, deliveryFee) {
+    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);
+    }
+}
+async function sendOrderStatusUpdate(email, name, status) {
+    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);
+    }
+}
+async function sendAdminNotification(name, items, totalAmount, customerEmail, deliveryFee) {
+    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);
+    }
+}
+async function sendContactEmail(name, email, phone, eventType, message) {
+    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/dist/utils/paginate.util.d.ts

@@ -0,0 +1,13 @@
+export declare function paginate(items: any[], page: number, limit: number, length: number): {
+    items: any[];
+    totalPages: number;
+    currentPage: number;
+    pages?: undefined;
+    pageRange?: undefined;
+} | {
+    items: any[];
+    pages: number;
+    pageRange: string;
+    totalPages?: undefined;
+    currentPage?: undefined;
+};

package/dist/utils/paginate.util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginate = paginate;
+function paginate(items, page, limit, length) {
+    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}`,
+    };
+}

package/package.json

@@ -1,27 +1,34 @@
 {
   "name": "server-core-module",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start": "ts-node src/server.ts",
+    "dev": "nodemon --exec ts-node src/server.ts",
+    "build": "tsc"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "type": "commonjs",
   "dependencies": {
+    "cloudinary": "^2.9.0",
+    "cors": "^2.8.6",
     "dotenv": "^17.3.1",
     "express": "^5.2.1",
     "joi": "^18.0.2",
+    "jsonwebtoken": "^9.0.3",
     "mongodb": "^7.1.0",
     "nodemailer": "^8.0.1"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^25.3.0",
     "@types/nodemailer": "^7.0.11",
+    "nodemon": "^3.1.14",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   }
-}
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}