add orders collecrtion for coins and subscriptions page

functions/src/orders.js

@@ -0,0 +1,190 @@
+const admin = require("firebase-admin");
+const { onDocumentCreated } = require("firebase-functions/firestore");
+const { HttpsError, onCall } = require("firebase-functions/https");
+
+const { REGION } = require("../index");
+const {
+  ORDER_TYPES,
+  ORDER_STATUS,
+  ORDERS_COLLECTION,
+  createOrderDocument,
+  normalizeAmount,
+} = require("./helpers/orders");
+
+const USERS_COLLECTION = "users";
+
+const onOrderCreated = onDocumentCreated(
+  `${ORDERS_COLLECTION}/{orderId}`,
+  async (event) => {
+    const orderRef = event?.data?.ref;
+    const orderData = event?.data?.data();
+
+    if (!orderRef || !orderData) {
+      return;
+    }
+
+    if (orderData?.processedAt) {
+      return;
+    }
+
+    const userId =
+      typeof orderData.userId === "string" ? orderData.userId.trim() : "";
+    const amount = normalizeAmount(orderData.amount);
+
+    if (!userId) {
+      await orderRef.set(
+        {
+          status: ORDER_STATUS.REJECTED,
+          processedAt: admin.firestore.FieldValue.serverTimestamp(),
+          failureReason: "USER_NOT_FOUND",
+        },
+        { merge: true },
+      );
+      return;
+    }
+
+    if (amount === null || amount === 0) {
+      await orderRef.set(
+        {
+          status: ORDER_STATUS.REJECTED,
+          processedAt: admin.firestore.FieldValue.serverTimestamp(),
+          failureReason: "INVALID_AMOUNT",
+        },
+        { merge: true },
+      );
+      return;
+    }
+
+    const userRef = admin.firestore().collection(USERS_COLLECTION).doc(userId);
+
+    try {
+      await admin.firestore().runTransaction(async (transaction) => {
+        const userSnapshot = await transaction.get(userRef);
+        const userData = userSnapshot?.data() || {};
+        const currentBalanceValue = normalizeAmount(userData?.coins);
+        const currentBalance =
+          currentBalanceValue !== null ? currentBalanceValue : 0;
+
+        const nextBalance = currentBalance + amount;
+
+        if (
+          amount < 0 &&
+          nextBalance < 0 &&
+          orderData?.type === ORDER_TYPES.SONG
+        ) {
+          transaction.set(
+            orderRef,
+            {
+              status: ORDER_STATUS.REJECTED,
+              processedAt: admin.firestore.FieldValue.serverTimestamp(),
+              failureReason: "INSUFFICIENT_FUNDS",
+              balanceBefore: currentBalance,
+              balanceAfter: currentBalance,
+            },
+            { merge: true },
+          );
+          return;
+        }
+
+        if (userSnapshot?.exists) {
+          transaction.update(userRef, {
+            coins: nextBalance,
+            updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+          });
+        } else {
+          transaction.set(
+            userRef,
+            {
+              coins: nextBalance,
+              createdAt: admin.firestore.FieldValue.serverTimestamp(),
+              updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+            },
+            { merge: true },
+          );
+        }
+
+        transaction.set(
+          orderRef,
+          {
+            status: ORDER_STATUS.APPLIED,
+            processedAt: admin.firestore.FieldValue.serverTimestamp(),
+            balanceBefore: currentBalance,
+            balanceAfter: nextBalance,
+          },
+          { merge: true },
+        );
+      });
+    } catch (error) {
+      console.error(
+        "[orders-onOrderCreated] Failed to process order",
+        orderRef.id,
+        error,
+      );
+
+      await orderRef.set(
+        {
+          status: ORDER_STATUS.REJECTED,
+          processedAt: admin.firestore.FieldValue.serverTimestamp(),
+          failureReason: "PROCESSING_ERROR",
+          errorMessage: error?.message || String(error),
+        },
+        { merge: true },
+      );
+    }
+  },
+);
+
+const createSongOrder = onCall({ region: REGION }, async (request) => {
+  const { auth, data } = request || {};
+
+  if (!auth?.uid) {
+    throw new HttpsError("unauthenticated", "Authentification requise.");
+  }
+
+  const amount = normalizeAmount(data?.amount);
+
+  if (amount === null || amount >= 0) {
+    throw new HttpsError(
+      "invalid-argument",
+      "Le montant doit être négatif pour un achat de musique.",
+    );
+  }
+
+  const songId =
+    typeof data?.songId === "string" && data.songId.trim()
+      ? data.songId.trim()
+      : null;
+
+  const userRef = admin.firestore().collection(USERS_COLLECTION).doc(auth.uid);
+  const userSnapshot = await userRef.get();
+  const currentCoinsValue = normalizeAmount(userSnapshot?.data()?.coins);
+  const currentCoins =
+    currentCoinsValue !== null ? currentCoinsValue : 0;
+
+  if (currentCoins + amount < 0) {
+    throw new HttpsError(
+      "failed-precondition",
+      "Crédits insuffisants pour finaliser l'opération.",
+    );
+  }
+
+  const { orderId } = await createOrderDocument({
+    userId: auth.uid,
+    type: ORDER_TYPES.SONG,
+    amount,
+    songId,
+    createdBy: auth.uid,
+    metadata: {
+      source: data?.source || "music_generation",
+      requestId:
+        typeof data?.requestId === "string" ? data.requestId : undefined,
+    },
+  });
+
+  return { orderId };
+});
+
+module.exports = {
+  onOrderCreated,
+  createSongOrder,
+};