@alphasquad/saleor-template-advance 0.1.0

package/src/app/api/paypal/capture-order/route.ts

@@ -0,0 +1,303 @@
+import { NextRequest, NextResponse } from "next/server";
+
+const TRANSACTION_PROCESS = `
+  mutation TransactionProcess(
+    $id: ID!
+    $data: JSON
+  ) {
+    transactionProcess(
+      id: $id
+      data: $data
+    ) {
+      transaction {
+        id
+        actions
+        chargedAmount {
+          amount
+          currency
+        }
+        checkout {
+          id
+        }
+        order {
+          id
+          number
+          total {
+            gross {
+              amount
+              currency
+            }
+          }
+        }
+      }
+      transactionEvent {
+        pspReference
+        message
+        type
+      }
+      data
+      errors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+const CHECKOUT_COMPLETE = `
+  mutation CheckoutComplete($checkoutId: ID!) {
+    checkoutComplete(checkoutId: $checkoutId) {
+      order {
+        id
+        number
+        total {
+          gross {
+            amount
+            currency
+          }
+        }
+      }
+      errors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { checkoutId, orderId, transactionId } = body;
+
+
+    if (!checkoutId || !orderId) {
+      return NextResponse.json(
+        { error: "Missing required fields: checkoutId, orderId" },
+        { status: 400 }
+      );
+    }
+
+    // If no transactionId provided, we'll try to use checkoutId
+    const txnId = transactionId || checkoutId;
+
+    // Get Saleor API URL
+    const apiUrl = process.env.NEXT_PUBLIC_API_URL;
+    if (!apiUrl) {
+      throw new Error("NEXT_PUBLIC_API_URL is not configured");
+    }
+
+    // Get auth token from request cookies
+    const token = request.cookies.get("token")?.value;
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+
+    // Step 1: Process the transaction with PayPal order ID
+    const processResponse = await fetch(apiUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        query: TRANSACTION_PROCESS,
+        variables: {
+          id: txnId,
+          data: {
+            paypalOrderId: orderId,
+          },
+        },
+      }),
+    });
+
+    if (!processResponse.ok) {
+      const errorText = await processResponse.text();
+      console.error("❌ Response body:", errorText);
+      throw new Error(`Transaction process request failed: ${processResponse.status}`);
+    }
+
+    const processResult = await processResponse.json();
+
+    const processData = processResult.data;
+    const processErrors = processResult.errors;
+
+    if (processErrors || processData?.transactionProcess?.errors?.length > 0) {
+      const errorMessage =
+        processData?.transactionProcess?.errors?.[0]?.message ||
+        processErrors?.[0]?.message ||
+        "Failed to process transaction";
+
+
+      return NextResponse.json({ error: errorMessage }, { status: 400 });
+    }
+
+    const transactionEvent = processData?.transactionProcess?.transactionEvent;
+    const eventType = transactionEvent?.type;
+
+
+    // Check if payment was successful
+    if (eventType && !eventType.includes("SUCCESS")) {
+      if (eventType.includes("FAILURE")) {
+        return NextResponse.json(
+          { error: `Payment failed: ${transactionEvent?.message || "Unknown error"}` },
+          { status: 400 }
+        );
+      }
+    }
+
+    // Check if order was created by transactionProcess
+    const transaction = processData?.transactionProcess?.transaction;
+    let order = transaction?.order;
+
+    // If no order exists yet, try to complete the checkout manually
+    if (!order) {
+      // Avoid noisy logs in templates/production.
+
+      // Try to complete the checkout manually
+      const completeResponse = await fetch(apiUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          query: CHECKOUT_COMPLETE,
+          variables: {
+            checkoutId: checkoutId,
+          },
+        }),
+      });
+
+      if (!completeResponse.ok) {
+        console.error("❌ checkoutComplete request failed:", completeResponse.status);
+
+        // Return processing status - the webhook might complete it
+        return NextResponse.json(
+          {
+            error: "Payment is being processed. Please wait a moment and check your order status.",
+            checkoutId,
+            transactionId: transaction?.id,
+            status: "processing",
+            message: "The payment has been authorized with PayPal. Your order is being created.",
+          },
+          { status: 202 } // 202 Accepted - processing
+        );
+      }
+
+      const completeResult = await completeResponse.json();
+      const completeData = completeResult.data;
+      const completeErrors = completeResult.errors || completeData?.checkoutComplete?.errors;
+
+      if (completeErrors && completeErrors.length > 0) {
+        console.error("❌ checkoutComplete errors:", completeErrors);
+
+        // Check if it's a duplicate key error (order already created)
+        const isDuplicateError = completeErrors.some((err: { message?: string; extensions?: { exception?: { code?: string } } }) =>
+          err.message?.includes('duplicate key') ||
+          err.message?.includes('already exists') ||
+          err.extensions?.exception?.code === 'IntegrityError'
+        );
+
+        if (isDuplicateError) {
+          // Avoid noisy logs in templates/production.
+
+          // Re-fetch transaction to get the order that was created
+          const recheckResponse = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+              query: TRANSACTION_PROCESS,
+              variables: {
+                id: txnId,
+                data: {
+                  paypalOrderId: orderId,
+                },
+              },
+            }),
+          });
+
+          if (recheckResponse.ok) {
+            const recheckResult = await recheckResponse.json();
+            const recheckOrder = recheckResult.data?.transactionProcess?.transaction?.order;
+
+            if (recheckOrder) {
+              order = recheckOrder;
+            }
+          }
+
+          // If still no order after recheck, return processing status
+          if (!order) {
+            return NextResponse.json(
+              {
+                error: "Payment is being processed. Please wait a moment and check your order status.",
+                checkoutId,
+                transactionId: transaction?.id,
+                status: "processing",
+                message: "The payment has been authorized with PayPal. Your order is being created.",
+              },
+              { status: 202 } // 202 Accepted - processing
+            );
+          }
+        } else {
+          // Other errors - return processing status
+          return NextResponse.json(
+            {
+              error: "Payment is being processed. Please wait a moment and check your order status.",
+              checkoutId,
+              transactionId: transaction?.id,
+              status: "processing",
+              message: "The payment has been authorized with PayPal. Your order is being created.",
+              details: completeErrors,
+            },
+            { status: 202 } // 202 Accepted - processing
+          );
+        }
+      }
+
+      if (!order) {
+        order = completeData?.checkoutComplete?.order;
+      }
+
+      if (!order) {
+        console.warn("⚠️ checkoutComplete did not create order - may still be processing");
+
+        // Return processing status
+        return NextResponse.json(
+          {
+            error: "Payment is being processed. Please wait a moment and check your order status.",
+            checkoutId,
+            transactionId: transaction?.id,
+            status: "processing",
+            message: "The payment has been authorized with PayPal. Your order is being created.",
+          },
+          { status: 202 } // 202 Accepted - processing
+        );
+      }
+
+      // Avoid noisy logs in templates/production.
+    }
+
+    // Avoid noisy logs in templates/production.
+
+    return NextResponse.json({
+      success: true,
+      order: {
+        id: order.id,
+        number: order.number,
+        total: order.total.gross.amount,
+        currency: order.total.gross.currency,
+      },
+    });
+  } catch (error) {
+    console.error("❌ Error in capture-order API:", error);
+
+    return NextResponse.json(
+      {
+        error: error instanceof Error ? error.message : "Internal server error",
+      },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/paypal/create-order/route.ts

@@ -0,0 +1,211 @@
+import { NextRequest, NextResponse } from "next/server";
+
+const TRANSACTION_INITIALIZE = `
+  mutation TransactionInitialize(
+    $id: ID!
+    $amount: PositiveDecimal!
+    $paymentGateway: PaymentGatewayToInitialize!
+    $idempotencyKey: String
+  ) {
+    transactionInitialize(
+      id: $id
+      amount: $amount
+      paymentGateway: $paymentGateway
+      idempotencyKey: $idempotencyKey
+    ) {
+      transaction {
+        id
+        actions
+      }
+      transactionEvent {
+        pspReference
+        amount {
+          amount
+          currency
+        }
+        type
+      }
+      data
+      errors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { checkoutId, amount, currency = "USD" } = body;
+
+
+    if (!checkoutId || !amount) {
+      return NextResponse.json(
+        { error: "Missing required fields: checkoutId, amount" },
+        { status: 400 }
+      );
+    }
+
+    // Get Saleor API URL
+    const apiUrl = process.env.NEXT_PUBLIC_API_URL;
+    if (!apiUrl) {
+      throw new Error("NEXT_PUBLIC_API_URL is not configured");
+    }
+
+
+    // Get auth token from request cookies
+    const token = request.cookies.get("token")?.value;
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+
+    // Add auth token if available (needed for checkout access)
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+
+    // Generate idempotency key for safe retries
+    const idempotencyKey = `paypal-${checkoutId}-${Date.now()}`;
+
+    // Get the storefront URL for return/cancel URLs
+    const storefrontUrl =
+      process.env.NEXT_PUBLIC_STOREFRONT_URL ||
+      request.headers.get("origin") ||
+      "http://localhost:3000";
+
+    const requestBody = {
+      query: TRANSACTION_INITIALIZE,
+      variables: {
+        id: checkoutId,
+        amount: amount.toString(),
+        // action: "CHARGE",  // REMOVED: This field requires HANDLE_PAYMENTS permission
+        paymentGateway: {
+          id: "saleor.app.payment.paypal",
+          data: {
+            // Pass return and cancel URLs to PayPal app
+            returnUrl: `${storefrontUrl}/checkout?checkoutId=${checkoutId}&payment=success`,
+            cancelUrl: `${storefrontUrl}/checkout?checkoutId=${checkoutId}&payment=cancelled`,
+          },
+        },
+        idempotencyKey,
+      },
+    };
+
+
+    // Call Saleor's transaction initialize mutation
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody),
+    });
+
+    // Always try to parse the response body to see GraphQL errors
+    const result = await response.json();
+
+    if (!response.ok) {
+      console.error(
+        "❌ GraphQL request failed:",
+        response.status,
+        response.statusText
+      );
+      console.error("❌ Response body:", result);
+
+      // Try to extract more specific error from GraphQL response
+      const errorDetail =
+        result.errors?.[0]?.message || result.error || response.statusText;
+      throw new Error(
+        `GraphQL request failed: ${response.status} - ${errorDetail}`
+      );
+    }
+
+    const data = result.data;
+    const graphqlErrors = result.errors;
+
+    if (graphqlErrors || data?.transactionInitialize?.errors?.length > 0) {
+      const errorMessage =
+        data?.transactionInitialize?.errors?.[0]?.message ||
+        graphqlErrors?.[0]?.message ||
+        "Failed to initialize transaction";
+
+      console.error("❌ Transaction initialize error:", errorMessage);
+
+      return NextResponse.json({ error: errorMessage }, { status: 400 });
+    }
+
+    // Extract PayPal order ID from response
+    // Saleor's PayPal app returns the order ID in the `data` field
+    const responseData = data?.transactionInitialize?.data;
+    const transactionId = data?.transactionInitialize?.transaction?.id;
+    const transactionEvent = data?.transactionInitialize?.transactionEvent;
+    const errors = data?.transactionInitialize?.errors;
+
+    // Avoid noisy logs (and accidental sensitive output) in templates/production.
+
+    // Check if the transaction failed
+    if (
+      transactionEvent?.type === "CHARGE_FAILURE" ||
+      transactionEvent?.type === "AUTHORIZATION_FAILURE"
+    ) {
+      console.error("❌ PayPal transaction failed:", {
+        eventType: transactionEvent.type,
+        responseData,
+        errors,
+      });
+
+      return NextResponse.json(
+        {
+          error: "Transaction failed",
+          eventType: transactionEvent.type,
+          transactionId,
+          responseData,
+          errors,
+        },
+        { status: 400 }
+      );
+    }
+
+    // The PayPal order ID is in responseData.paypal_order_id
+    const orderId =
+      responseData?.paypal_order_id ||
+      responseData?.paypalOrderId ||
+      responseData?.orderId ||
+      transactionEvent?.pspReference;
+
+    if (!orderId) {
+      console.error("❌ No PayPal order ID in response:", {
+        responseData,
+        transactionEvent,
+      });
+      return NextResponse.json(
+        {
+          error: "No PayPal order ID in response",
+          responseData,
+          transactionEvent,
+        },
+        { status: 500 }
+      );
+    }
+
+    // Avoid noisy logs in templates/production.
+
+    return NextResponse.json({
+      orderId,
+      transactionId,
+      checkoutId,
+      amount,
+      currency,
+    });
+  } catch (error) {
+    console.error("❌ Error in create-order API:", error);
+
+    return NextResponse.json(
+      {
+        error: error instanceof Error ? error.message : "Internal server error",
+      },
+      { status: 500 }
+    );
+  }
+}