Feature/membership final refactor

src/config/docs/MembershipSchema.yml

@@ -0,0 +1,68 @@
+components:
+  schemas:
+    GetSingleMembershipRs:
+      type: object
+      properties:
+        pi_uid:
+          type: string
+          description: The Pi Network user ID (used as membership identifier)
+          example: pi_f392cb3b73913bcb2d1e5b69
+        membership_class:
+          $ref: '/api/docs/enum/MembershipClassType.yml#/components/schemas/MembershipClassType'
+        membership_expiration:
+          type: string
+          format: date-time
+          example: 2024-12-21T00:00:00.000Z
+        mappi_balance:
+          type: number
+          example: 100
+        mappi_used_to_date:
+          type: number
+          example: 25
+        _id:
+          type: string
+          example: 66741c62b175e7d059a2639e
+        __v:
+          type: number
+          example: 0
+
+    ManageMembershipRq:
+      type: object
+      properties:
+        membership_class:
+          $ref: '/api/docs/enum/MembershipClassType.yml#/components/schemas/MembershipClassType'
+        membership_duration:
+          type: number 
+          example: 4
+        mappi_allowance:
+          type: number
+          example: 100
+      required:
+        - membership_class
+        - membership_duration
+        - mappi_allowance
+
+    ManageMembershipRs:
+      type: object
+      properties:
+        pi_uid:
+          type: string
+          example: pi_f392cb3b73913bcb2d1e5b69
+        membership_class:
+          $ref: '/api/docs/enum/MembershipClassType.yml#/components/schemas/MembershipClassType'
+        membership_expiration:
+          type: string
+          format: date-time
+          example: 2024-12-21T00:00:00.000Z
+        mappi_balance:
+          type: number
+          example: 200
+        mappi_used_to_date:
+          type: number
+          example: 0
+        _id:
+          type: string
+          example: 66741c62b175e7d059a2639e
+        __v:
+          type: number
+          example: 0

src/config/platformAPIclient.ts

@@ -1,5 +1,5 @@
 import axios from "axios";
-import PiNetwork from 'pi-backend';
+import Pi from "pi-backend";
 import { env } from "../utils/env";
 
 export const platformAPIClient = axios.create({
@@ -13,6 +13,4 @@ export const platformAPIClient = axios.create({
 const apiKey = env.PI_API_KEY || '';
 const walletSeed = env.WALLET_PRIVATE_SEED || '';
 
-const pi = new PiNetwork(apiKey, walletSeed);
-
-export default pi;
+export const piNetwork = new Pi(apiKey, walletSeed); 

src/controllers/membershipController.ts

@@ -0,0 +1,45 @@
+import { Request, Response } from "express";
+import * as membershipService from "../services/membership.service";
+import logger from "../config/loggingConfig";
+
+// Controller to fetch a single membership by its ID
+export const getSingleMembership = async (req: Request, res: Response) => {
+  const { membership_id } = req.params;
+
+  try {
+    const currentMembership = await membershipService.getSingleMembershipById(membership_id);
+
+    if (!currentMembership) {
+      logger.warn(`Membership with ID ${membership_id} not found.`);
+      return res.status(404).json({ message: "Membership not found" });
+    }
+
+    logger.info(`Fetched membership with ID ${membership_id}`);
+    return res.status(200).json(currentMembership);
+  } catch (error) {
+    logger.error(`Error getting membership ID ${membership_id}:`, error);
+    return res.status(500).json({ message: 'An error occurred while getting single membership; please try again later' });
+  }
+};
+
+export const updateOrRenewMembership = async (req: Request, res: Response) => {
+ if (!req.currentUser) {
+  return res.status(401).json({ error: "Unauthorized - user not authenticated "});
+ }
+
+  try {
+    const { membership_class, membership_duration, mappi_allowance } = req.body;
+
+    const updated = await membershipService.updateOrRenewMembership({
+      user: req.currentUser,
+      membership_class,
+      membership_duration,
+      mappi_allowance,
+    });
+
+    return res.status(200).json(updated);
+  } catch (error: any) {
+    logger.error("Failed to update or renew membership:", error);
+    return res.status(400).json({ error: error.message });
+  }
+};

src/controllers/membershipLegacy.controller.ts

@@ -0,0 +1,47 @@
+import { Request, Response } from "express";
+import * as membershipLegacyService from "../services/membershipLegacy.service";
+import logger from "../config/loggingConfig";
+import { MembershipClassType } from "../models/enums/membershipClassType";
+
+// Controller to add or update a user's membership
+// !!! Legacy controller — used only for manual upgrades and testing.
+// Membership upgrades should now go through Pi (U2A) payment flow.
+export const manageMembership = async (req: Request, res: Response) => {
+    const authUser = req.currentUser;
+
+    // Early return if request is not authenticated
+    if (!authUser) {
+      logger.warn('Unauthorized attempt to manage membership.');
+      return res.status(401).json({ error: 'Unauthorized' });
+    }
+
+    const { membership_class, membership_duration, mappi_allowance } = req.body;
+
+    // Basic input validation
+    if (
+      !membership_class || 
+      !Object.values(MembershipClassType).includes(membership_class) || // Ensure membership_class is valid
+      typeof membership_duration !== 'number' ||
+      typeof mappi_allowance !== 'number'                               
+    ) {
+      return res.status(400).json({ error: 'Invalid request payload' });
+    }
+
+    try {
+      // Add or update membership in the service layer
+      const updatedMembership = await membershipLegacyService.addOrUpdateMembershipLegacy(
+        authUser,
+        membership_class,
+        membership_duration,
+        mappi_allowance
+      );
+
+      logger.info(`Membership managed successfully for user ${authUser.pi_uid}`);
+      return res.status(200).json(updatedMembership);
+    } catch (error) {
+      logger.error(`Failed to manage membership for user ${authUser.pi_uid}:`, error);
+      return res.status(500).json({
+        message: 'An error occurred while getting single membership; please try again later',
+      });
+    }
+  };

src/controllers/paymentController.ts

@@ -1,27 +1,66 @@
 import { Request, Response } from "express";
 import logger from "../config/loggingConfig";
-import { 
+import {
   processIncompletePayment, 
   processPaymentApproval, 
   processPaymentCancellation, 
   processPaymentCompletion
 } from "../helpers/payment";
-import { IUser } from "../types";
+import { IUser, PaymentDataType } from "../types";
+import { createU2APayment } from "../services/payment.service";
+
+export const onPaymentInitiation = async (req: Request, res: Response) => {
+  try {
+    const currentUser = req.currentUser as IUser;
+    const paymentData = req.body as PaymentDataType;
+
+    const { memo, amount, metadata } = paymentData;
+
+    if (!memo || !amount || !metadata?.payment_type) {
+      return res.status(400).json({ message: "Missing required payment fields" });
+    }
+
+    const newPayment = await createU2APayment(currentUser, paymentData);
+
+    if (!newPayment) {
+      return res.status(500).json({ success: false, message: "Failed to initiate payment" });
+    }
+
+    res.status(200).json({
+      success: true,
+      message: "Payment created successfully",
+      payment_id: newPayment._id,
+    });
+  } catch (error: any) {
+    logger.error("Payment initiation failed", { error });
+    res.status(500).json({ success: false, message: "Failed to initiate payment" });
+  }
+};
 
 export const onIncompletePaymentFound = async (req: Request, res: Response) => {
- const { payment } = req.body;
+  const { payment } = req.body;
+
+  if (!payment || typeof payment !== "object" || !payment.identifier) {
+    logger.warn("Invalid or missing payment payload in onIncompletePaymentFound", { payment });
+    return res.status(400).json({
+      success: false,
+      message: "Invalid payment data provided.",
+    });
+  }
+
   try {
     const processedPayment = await processIncompletePayment(payment);
     return res.status(200).json(processedPayment);
   } catch (error) {
-    logger.error(`Failed to process incomplete payment for paymentID ${ payment.identifier }:`, error);
+    logger.error(`Failed to process incomplete payment for paymentID ${payment.identifier}:`, error);
     return res.status(500).json({ 
       success: false,
       message: 'An error occurred while processing incomplete payment; please try again later' 
     });
   }
 };
 
+
 export const onPaymentApproval = async (req: Request, res: Response) => {
   const currentUser = req.currentUser as IUser;
   const { paymentId } = req.body;

src/helpers/payment.ts

@@ -20,6 +20,7 @@ import {
 } from '../services/order.service';
 import { IUser, NewOrder, PaymentDataType, PaymentInfo } from '../types';
 import logger from '../config/loggingConfig';
+import { updateOrRenewMembershipAfterPayment  } from '../services/membership.service';
 
 function buildPaymentData(
   piPaymentId: string,
@@ -79,7 +80,8 @@ const checkoutProcess = async (
   }
 
   // Construct payment data object for recording the transaction
-  const paymentData = buildPaymentData(piPaymentId, buyer._id as string, currentPayment);
+  const paymentData = buildPaymentData(piPaymentId, buyer._id.toString()
+, currentPayment);
   // Create a new payment record
   const newPayment = await createPayment(paymentData)
   // Validate payment record creation succeeded
@@ -96,7 +98,7 @@ const checkoutProcess = async (
 
   // Construct order data object
   const orderData = buildOrderData(
-    buyer._id as string,
+    buyer._id.toString(),
     seller._id as string,
     newPayment._id as string,
     currentPayment
@@ -183,21 +185,30 @@ export const processPaymentApproval = async (
       };
     }
 
-    // Handle logic based on the payment type
-    if (currentPayment?.metadata.payment_type === PaymentType.BuyerCheckout) {
-      const newOrder = await checkoutProcess(paymentId, currentUser, currentPayment);
-      logger.info("Order created successfully: ", newOrder._id);
-    } else if (currentPayment?.metadata.payment_type === PaymentType.Membership) {
-      logger.info("Membership subscription processed successfully");
+  // Handle logic based on the payment type
+  if (currentPayment?.metadata.payment_type === PaymentType.BuyerCheckout) {
+    const newOrder = await checkoutProcess(paymentId, currentUser, currentPayment);
+    logger.info("Order created successfully: ", newOrder._id);
+
+  } else if (currentPayment?.metadata.payment_type === PaymentType.Membership) {
+    const metadata = currentPayment.metadata.MembershipPayment;
+
+    if (!metadata || !metadata.membership_id) {
+      throw new Error("Missing or invalid membership metadata");
     }
 
-    // Approve the payment on the Pi platform
-    await platformAPIClient.post(`/v2/payments/${ paymentId }/approve`);
+    await updateOrRenewMembershipAfterPayment(currentPayment);
+    logger.info(`Membership subscription processed successfully for pi_uid: ${metadata.pi_uid}`);
+  }
+
+  // Approve the payment on the Pi platform
+  await platformAPIClient.post(`/v2/payments/${ paymentId }/approve`);
+
+  return {
+    success: true,
+    message: `Payment approved with id ${ paymentId }`,
+  };
 
-    return {
-      success: true,
-      message: `Payment approved with id ${ paymentId }`,
-    };
   } catch (error: any) {
     if (error.response) {
       logger.error("platformAPIClient error", {