@akinon/next 2.0.34-rc.0 → 2.0.35-beta.0

package/CHANGELOG.md

@@ -1,32 +1,16 @@
 # @akinon/next
 
-## 2.0.34-rc.0
+## 2.0.35-beta.0
 
 ### Patch Changes
 
-- 0cf9ea239: BRDG-16491: Prevent redirect when iframe payment is active
-- 324f97d5: ZERO-4219: replace masterpass-rest-complete with masterpass-rest-callback
-- 51ea0688: ZERO-4377: Fix checkout card type state being cleared after valid bin number responses.
-- ZERO-4160: Enhance oauth-login middleware with improved request handling and logging
-- b55acb768: ZERO-2577: Fix pagination bug and update usePagination hook and ensure pagination controls rendering correctly
-- 760258c1c: ZERO-4160: Enhance oauth-login middleware to handle fetch errors and improve response handling
-- 143be2b9: ZERO-3457: Crop styles are customizable and logic improved for rendering similar products modal
-- 7889b08f: ZERO-4276: Enhance route generation by adding .env loading and custom skip segments support
-- 9f8cd3bc5: ZERO-3449: AI Search Active Filters & Crop Style changes have been implemented
-- bfafa3f49: ZERO-4160: Refactor oauth-login middleware to use fetchCommerce for API calls and improve cookie handling
-- 57d7eb30: ZERO-4276: Refactor route generation logic by removing environment loading and simplifying skip segments handling
-- d99a6a7d: ZERO-3457_1: Fixed the settings prop and made sure everything is customizable.
-- 9db81a71: ZERO-4365: Remove brand `@theme/*` alias imports from library packages
-- 591e345e: ZERO-3855: Enhance credit card payment handling in checkout middlewares
-- 4de5303c5: ZERO-2504: add cookie filter to api client request
-- 95b139dc: ZERO-3795: Remove duplicate entry for SavedCard in PluginComponents map
-- 1d00f2d0: BRDG-16664: Set secure flag for CSRF token cookies in useCaptcha and default middleware
-- 4ac7b2a1e: ZERO-4219: fix masterpass-rest callback route format and double-encoded error cookie
-- 4998a9631: ZERO-4168: Add server-side payload optimization
-- 804d2bd6: ZERO-4536: Add akinon.net domain to CSP frame-ancestors directive
-- 3909d3224: Edit the duplicate Plugin.SimilarProducts in the plugin-module.
-- 6a3d8a63: ZERO-4541: Fix URL query string formatting in getOrders and getOldOrders functions
-- e18836b20: ZERO-4160: Restore scope in Sentry addon configuration in akinon.json
+- cbbbfd75: ZERO-4376: Bootstrap beta cycle (next-main pre-release motor)
+
+## 2.0.34
+
+### Patch Changes
+
+- 4e2ea16b: ZERO-4582: enhance virtual try-on functionality with single and async mutations
 
 ## 2.0.33
 

package/api/virtual-try-on.ts

@@ -48,20 +48,100 @@ function getLocaleFromRequest(request: NextRequest): string | null {
   return null;
 }
 
-export async function GET(request: NextRequest) {
-  try {
+export const createVirtualTryOnHandlers = (opts?: {
+  auth?: () => Promise<any>;
+}) => {
+  const getIdentityHeaders = async (
+    request: NextRequest
+  ): Promise<Record<string, string>> => {
+    const sessionId = request.cookies.get('osessionid')?.value;
+
+    let userId: string | undefined;
+    if (opts?.auth) {
+      try {
+        const session = await opts.auth();
+        if (session?.user?.pk !== undefined && session?.user?.pk !== null) {
+          userId = String(session.user.pk);
+        }
+      } catch (error) {
+        userId = undefined;
+      }
+    }
+
+    return {
+      ...(sessionId && { 'X-Session-Id': sessionId }),
+      ...(userId && { 'X-User-Id': userId })
+    };
+  };
+
+  const GET = async (request: NextRequest) => {
     const { searchParams } = new URL(request.url);
     const endpoint = searchParams.get('endpoint');
 
-    if (endpoint === 'limited-categories') {
-      const now = Date.now();
+    try {
+      if (endpoint === 'limited-categories') {
+        const now = Date.now();
+
+        if (
+          limitedCategoriesCache &&
+          now - limitedCategoriesCache.timestamp < CACHE_TTL
+        ) {
+          return NextResponse.json(limitedCategoriesCache.data, {
+            status: 200,
+            headers: {
+              'Access-Control-Allow-Origin': '*',
+              'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
+              'Access-Control-Allow-Headers':
+                'Content-Type, Accept, Authorization',
+              'Cache-Control':
+                'public, s-maxage=3600, stale-while-revalidate=7200',
+              'X-Virtual-Try-On-Cache-Status': 'HIT'
+            }
+          });
+        }
+
+        const externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/limited-categories`;
+        const clientIP = getClientIP(request);
+        const locale = getLocaleFromRequest(request);
+        const identityHeaders = await getIdentityHeaders(request);
+
+        const headersToSend = {
+          Accept: 'application/json',
+          ...(locale && { 'Accept-Language': locale }),
+          ...(request.headers.get('authorization') && {
+            Authorization: request.headers.get('authorization')!
+          }),
+          ...(clientIP && {
+            'X-Forwarded-For': clientIP
+          }),
+          ...identityHeaders
+        };
+
+        const response = await fetch(externalUrl, {
+          method: 'GET',
+          headers: headersToSend
+        });
 
-      if (
-        limitedCategoriesCache &&
-        now - limitedCategoriesCache.timestamp < CACHE_TTL
-      ) {
-        return NextResponse.json(limitedCategoriesCache.data, {
-          status: 200,
+        let responseData: any;
+        const responseText = await response.text();
+
+        try {
+          responseData = responseText ? JSON.parse(responseText) : {};
+        } catch (parseError) {
+          responseData = { category_ids: [] };
+        }
+
+        if (!response.ok) {
+          responseData = { category_ids: [] };
+        }
+
+        limitedCategoriesCache = {
+          data: responseData,
+          timestamp: Date.now()
+        };
+
+        return NextResponse.json(responseData, {
+          status: response.ok ? response.status : 200,
           headers: {
             'Access-Control-Allow-Origin': '*',
             'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
@@ -69,100 +149,222 @@ export async function GET(request: NextRequest) {
               'Content-Type, Accept, Authorization',
             'Cache-Control':
               'public, s-maxage=3600, stale-while-revalidate=7200',
-            'X-Virtual-Try-On-Cache-Status': 'HIT'
+            'X-Virtual-Try-On-Cache-Status': 'MISS'
+          }
+        });
+      } else if (endpoint === 'job-status') {
+        const processId = searchParams.get('process_id');
+        if (!processId) {
+          return NextResponse.json(
+            { error: 'process_id is required' },
+            { status: 400 }
+          );
+        }
+
+        const externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/process/${encodeURIComponent(
+          processId
+        )}`;
+        const clientIP = getClientIP(request);
+        const locale = getLocaleFromRequest(request);
+        const identityHeaders = await getIdentityHeaders(request);
+
+        const headersToSend = {
+          Accept: 'application/json',
+          ...(locale && { 'Accept-Language': locale }),
+          ...(request.headers.get('authorization') && {
+            Authorization: request.headers.get('authorization')!
+          }),
+          ...(clientIP && {
+            'X-Forwarded-For': clientIP
+          }),
+          ...identityHeaders
+        };
+
+        const response = await fetch(externalUrl, {
+          method: 'GET',
+          headers: headersToSend
+        });
+
+        let responseData: any;
+        const responseText = await response.text();
+
+        try {
+          responseData = responseText ? JSON.parse(responseText) : {};
+        } catch (parseError) {
+          return NextResponse.json(
+            { error: 'Invalid JSON response from job status API' },
+            { status: 500 }
+          );
+        }
+
+        return NextResponse.json(responseData, {
+          status: response.status,
+          headers: {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization'
           }
         });
       }
 
-      const externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/limited-categories`;
+      return NextResponse.json(
+        { error: 'Invalid endpoint for GET method' },
+        { status: 400 }
+      );
+    } catch (error) {
+      if (endpoint === 'limited-categories') {
+        return NextResponse.json({ category_ids: [] }, { status: 200 });
+      }
+
+      return NextResponse.json(
+        {
+          status: 'error',
+          message: 'Internal server error occurred during virtual try-on request'
+        },
+        { status: 500 }
+      );
+    }
+  };
+
+  const POST = async (request: NextRequest) => {
+    try {
+      const { searchParams } = new URL(request.url);
+      const endpoint = searchParams.get('endpoint');
+
+      const body = await request.json();
+
+      let externalUrl: string;
+      let httpMethod = 'POST';
+
+      if (endpoint === 'feedback') {
+        if (!body.url || typeof body.url !== 'string' || !body.url.trim()) {
+          return NextResponse.json(
+            { status: 'error', message: 'URL is required for feedback' },
+            { status: 400 }
+          );
+        }
+        if (typeof body.feedback !== 'boolean') {
+          return NextResponse.json(
+            { status: 'error', message: 'Feedback must be a boolean value' },
+            { status: 400 }
+          );
+        }
+        externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/feedback`;
+        httpMethod = 'PUT';
+      } else if (endpoint === 'single-try-on') {
+        externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/virtual-try-on`;
+      } else if (endpoint === 'multiple-try-on') {
+        externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/multiple-virtual-try-on`;
+      } else if (endpoint === 'usage') {
+        externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/try-on-usage`;
+      } else if (endpoint === 'event') {
+        externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/try-on-event`;
+      } else {
+        return NextResponse.json(
+          { error: 'Invalid endpoint specified' },
+          { status: 400 }
+        );
+      }
+
       const clientIP = getClientIP(request);
       const locale = getLocaleFromRequest(request);
+      const identityHeaders = await getIdentityHeaders(request);
 
       const headersToSend = {
-        Accept: 'application/json',
+        'Content-Type': 'application/json',
         ...(locale && { 'Accept-Language': locale }),
+        ...(httpMethod === 'POST' && { Accept: 'application/json' }),
         ...(request.headers.get('authorization') && {
           Authorization: request.headers.get('authorization')!
         }),
         ...(clientIP && {
           'X-Forwarded-For': clientIP
-        })
+        }),
+        ...identityHeaders
       };
 
       const response = await fetch(externalUrl, {
-        method: 'GET',
-        headers: headersToSend
+        method: httpMethod,
+        headers: headersToSend,
+        body: JSON.stringify(body)
       });
 
-      let responseData: any;
+      let responseData: Record<string, any>;
       const responseText = await response.text();
 
       try {
         responseData = responseText ? JSON.parse(responseText) : {};
       } catch (parseError) {
-        responseData = { category_ids: [] };
-      }
-
-      if (!response.ok) {
-        responseData = { category_ids: [] };
+        responseData =
+          endpoint === 'feedback'
+            ? { error: 'Invalid JSON response from feedback API' }
+            : { error: 'Invalid JSON response' };
       }
 
-      limitedCategoriesCache = {
-        data: responseData,
-        timestamp: Date.now()
-      };
-
       return NextResponse.json(responseData, {
-        status: response.ok ? response.status : 200,
+        status: response.status,
         headers: {
           'Access-Control-Allow-Origin': '*',
-          'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
-          'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization',
-          'Cache-Control': 'public, s-maxage=3600, stale-while-revalidate=7200',
-          'X-Virtual-Try-On-Cache-Status': 'MISS'
+          'Access-Control-Allow-Methods': 'POST, OPTIONS',
+          'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization'
         }
       });
-    } else if (endpoint === 'job-status') {
-      const referenceUrl = searchParams.get('reference_url');
-      if (!referenceUrl) {
+    } catch (error) {
+      return NextResponse.json(
+        {
+          status: 'error',
+          message:
+            'Internal server error occurred during virtual try-on processing'
+        },
+        { status: 500 }
+      );
+    }
+  };
+
+  const PUT = async (request: NextRequest) => {
+    try {
+      const { searchParams } = new URL(request.url);
+      const endpoint = searchParams.get('endpoint');
+
+      if (endpoint !== 'feedback') {
         return NextResponse.json(
-          { error: 'reference_url is required' },
+          { error: 'PUT method only supports feedback endpoint' },
           { status: 400 }
         );
       }
 
-      const externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/async/v1/job-status?reference_url=${encodeURIComponent(
-        referenceUrl
-      )}`;
+      const body = await request.json();
+
+      const externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/feedback`;
       const clientIP = getClientIP(request);
       const locale = getLocaleFromRequest(request);
+      const identityHeaders = await getIdentityHeaders(request);
 
       const headersToSend = {
-        Accept: 'application/json',
+        'Content-Type': 'application/json',
         ...(locale && { 'Accept-Language': locale }),
         ...(request.headers.get('authorization') && {
           Authorization: request.headers.get('authorization')!
         }),
         ...(clientIP && {
           'X-Forwarded-For': clientIP
-        })
+        }),
+        ...identityHeaders
       };
 
       const response = await fetch(externalUrl, {
-        method: 'GET',
-        headers: headersToSend
+        method: 'PUT',
+        headers: headersToSend,
+        body: JSON.stringify(body)
       });
 
-      let responseData: any;
+      let responseData: Record<string, any>;
       const responseText = await response.text();
 
       try {
         responseData = responseText ? JSON.parse(responseText) : {};
       } catch (parseError) {
-        return NextResponse.json(
-          { error: 'Invalid JSON response from job status API' },
-          { status: 500 }
-        );
+        responseData = { error: 'Invalid JSON response from feedback API' };
       }
 
       return NextResponse.json(responseData, {
@@ -173,210 +375,30 @@ export async function GET(request: NextRequest) {
           'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization'
         }
       });
-    }
-
-    return NextResponse.json(
-      { error: 'Invalid endpoint for GET method' },
-      { status: 400 }
-    );
-  } catch (error) {
-    return NextResponse.json({ category_ids: [] }, { status: 200 });
-  }
-}
-
-export async function POST(request: NextRequest) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const endpoint = searchParams.get('endpoint');
-
-    const body = await request.json();
-
-    let externalUrl: string;
-    let httpMethod = 'POST';
-
-    if (endpoint === 'feedback') {
-      if (!body.url || typeof body.url !== 'string' || !body.url.trim()) {
-        return NextResponse.json(
-          { status: 'error', message: 'URL is required for feedback' },
-          { status: 400 }
-        );
-      }
-      if (typeof body.feedback !== 'boolean') {
-        return NextResponse.json(
-          { status: 'error', message: 'Feedback must be a boolean value' },
-          { status: 400 }
-        );
-      }
-      externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/feedback`;
-      httpMethod = 'PUT';
-    } else if (endpoint === 'async-multiple-try-on') {
-      externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/async/v1/multiple-virtual-try-on`;
-    } else {
-      return NextResponse.json(
-        { error: 'Invalid endpoint specified' },
-        { status: 400 }
-      );
-    }
-
-    const clientIP = getClientIP(request);
-    const locale = getLocaleFromRequest(request);
-
-    const headersToSend = {
-      'Content-Type': 'application/json',
-      ...(locale && { 'Accept-Language': locale }),
-      ...(httpMethod === 'POST' && { Accept: 'application/json' }),
-      ...(request.headers.get('authorization') && {
-        Authorization: request.headers.get('authorization')!
-      }),
-      ...(clientIP && {
-        'X-Forwarded-For': clientIP
-      })
-    };
-
-    const fetchOptions: RequestInit = {
-      method: httpMethod,
-      headers: headersToSend
-    };
-
-    if (httpMethod !== 'GET') {
-      fetchOptions.body = JSON.stringify(body);
-    }
-
-    const response = await fetch(externalUrl, fetchOptions);
-
-    let responseData: Record<string, any>;
-    const responseText = await response.text();
-
-    if (endpoint === 'feedback') {
-      try {
-        responseData = responseText ? JSON.parse(responseText) : {};
-      } catch (parseError) {
-        responseData = { error: 'Invalid JSON response from feedback API' };
-      }
-    } else {
-      try {
-        responseData = responseText ? JSON.parse(responseText) : {};
-      } catch (parseError) {
-        responseData = { error: 'Invalid JSON response' };
-      }
-    }
-
-    if (!response.ok && responseData.error) {
-      let userFriendlyMessage = responseData.error;
-
-      if (
-        typeof responseData.error === 'string' &&
-        (responseData.error.includes('duplicate key value') ||
-          responseData.error.includes('image_pk'))
-      ) {
-        userFriendlyMessage =
-          'This image has already been processed. Please try with a different image.';
-      } else if (responseData.error.includes('bulk insert images')) {
-        userFriendlyMessage =
-          'There was an issue processing your image. Please try again with a different image.';
-      }
-
+    } catch (error) {
       return NextResponse.json(
         {
-          ...responseData,
-          message: userFriendlyMessage
+          status: 'error',
+          message: 'Internal server error occurred during feedback submission',
+          error: (error as Error).message
         },
-        {
-          status: response.status,
-          headers: {
-            'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Methods': 'POST, OPTIONS',
-            'Access-Control-Allow-Headers':
-              'Content-Type, Accept, Authorization'
-          }
-        }
+        { status: 500 }
       );
     }
+  };
 
-    return NextResponse.json(responseData, {
-      status: response.status,
-      headers: {
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'POST, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization'
-      }
-    });
-  } catch (error) {
-    return NextResponse.json(
-      {
-        status: 'error',
-        message:
-          'Internal server error occurred during virtual try-on processing'
-      },
-      { status: 500 }
-    );
-  }
-}
-
-export async function PUT(request: NextRequest) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const endpoint = searchParams.get('endpoint');
-
-    if (endpoint !== 'feedback') {
-      return NextResponse.json(
-        { error: 'PUT method only supports feedback endpoint' },
-        { status: 400 }
-      );
-    }
-
-    const body = await request.json();
-
-    const externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/v1/feedback`;
-    const clientIP = getClientIP(request);
-    const locale = getLocaleFromRequest(request);
-
-    const headersToSend = {
-      'Content-Type': 'application/json',
-      ...(locale && { 'Accept-Language': locale }),
-      ...(request.headers.get('authorization') && {
-        Authorization: request.headers.get('authorization')!
-      }),
-      ...(clientIP && {
-        'X-Forwarded-For': clientIP
-      })
-    };
-
-    const response = await fetch(externalUrl, {
-      method: 'PUT',
-      headers: headersToSend,
-      body: JSON.stringify(body)
-    });
-
-    const responseData = response?.json() || {};
-
-    return NextResponse.json(responseData, {
-      status: response.status,
+  const OPTIONS = async () => {
+    return new NextResponse(null, {
+      status: 200,
       headers: {
         'Access-Control-Allow-Origin': '*',
         'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
         'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization'
       }
     });
-  } catch (error) {
-    return NextResponse.json(
-      {
-        status: 'error',
-        message: 'Internal server error occurred during feedback submission',
-        error: (error as Error).message
-      },
-      { status: 500 }
-    );
-  }
-}
+  };
 
-export async function OPTIONS() {
-  return new NextResponse(null, {
-    status: 200,
-    headers: {
-      'Access-Control-Allow-Origin': '*',
-      'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
-      'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization'
-    }
-  });
-}
+  return { GET, POST, PUT, OPTIONS };
+};
+
+export const { GET, POST, PUT, OPTIONS } = createVirtualTryOnHandlers();

package/bin/pz-generate-routes.js

@@ -6,7 +6,6 @@ const findBaseDir = require('../utils/find-base-dir');
 
 const generateRoutes = () => {
   const baseDir = findBaseDir();
-
   const srcDir = path.join(baseDir, 'src');
   const appDir = path.join(srcDir, 'app');
 
@@ -35,10 +34,8 @@ const generateRoutes = () => {
     '[segment]',
     '[url]',
     '[theme]',
-    '[member_type]',
-    '[clienttype]'
+    '[member_type]'
   ];
-
   const skipCatchAllRoutes = ['[...prettyurl]', '[...not_found]'];
 
   const walkDirectory = (dir, basePath = '') => {

package/components/plugin-module.tsx

@@ -116,6 +116,7 @@ const PluginComponents = new Map([
     ]
   ],
   [Plugin.SavedCard, [Component.SavedCard, Component.IyzicoSavedCard]],
+  [Plugin.SavedCard, [Component.SavedCard]],
   [Plugin.FlowPayment, [Component.FlowPayment]],
   [
     Plugin.VirtualTryOn,

package/data/client/checkout.ts

@@ -738,6 +738,7 @@ export const checkoutApi = api.injectEndpoints({
       },
       async onQueryStarted(arg, { dispatch, queryFulfilled }) {
         dispatch(setPaymentStepBusy(true));
+        dispatch(setCardType(arg));
         await queryFulfilled;
         dispatch(setPaymentStepBusy(false));
       }