@akinon/next 2.0.0-beta.2 → 2.0.0-beta.20

package/api/similar-product-list.ts

@@ -0,0 +1,63 @@
+import { NextRequest, NextResponse } from 'next/server';
+import Settings from 'settings';
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const dynamicFilter = request.headers.get('x-search-dynamic-filter');
+    const dynamicExclude = request.headers.get('x-search-dynamic-exclude');
+
+    if (!dynamicFilter && !dynamicExclude) {
+      return NextResponse.json(
+        {
+          error:
+            'Missing x-search-dynamic-filter or x-search-dynamic-exclude header'
+        },
+        { status: 400 }
+      );
+    }
+
+    if (Settings.commerceUrl === 'default') {
+      return NextResponse.json(
+        { error: 'Commerce URL is not configured' },
+        { status: 500 }
+      );
+    }
+
+    const queryString = searchParams.toString();
+    const apiUrl = `${Settings.commerceUrl}/list${
+      queryString ? `?${queryString}` : ''
+    }`;
+
+    const headers: Record<string, string> = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    };
+
+    if (dynamicFilter) {
+      headers['x-search-dynamic-filter'] = dynamicFilter;
+    } else if (dynamicExclude) {
+      headers['x-search-dynamic-exclude'] = dynamicExclude;
+    }
+
+    const response = await fetch(apiUrl, {
+      method: 'GET',
+      headers
+    });
+
+    if (!response.ok) {
+      return NextResponse.json(
+        { error: `API request failed with status: ${response.status}` },
+        { status: response.status }
+      );
+    }
+
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (error) {
+    return NextResponse.json(
+      { error: (error as Error).message },
+      { status: 500 }
+    );
+  }
+}

package/api/similar-products.ts

@@ -0,0 +1,111 @@
+import { NextResponse } from 'next/server';
+import Settings from 'settings';
+
+const IMAGE_SEARCH_API_URL = Settings.commerceUrl + '/image-search/';
+
+const errorResponse = (message: string, status: number) => {
+  return NextResponse.json({ error: message }, { status });
+};
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const limit = searchParams.get('limit') || '20';
+  const url = searchParams.get('url');
+  const excludedProductIds = searchParams.get('excluded_product_ids');
+
+  if (!url) {
+    return errorResponse('URL parameter is required', 400);
+  }
+
+  if (Settings.commerceUrl === 'default') {
+    return errorResponse('Commerce URL is not configured', 500);
+  }
+
+  const apiParams = new URLSearchParams();
+  apiParams.append('limit', limit);
+  apiParams.append('url', url);
+
+  if (excludedProductIds) {
+    apiParams.append('excluded_product_ids', excludedProductIds);
+  }
+
+  const apiUrl = `${IMAGE_SEARCH_API_URL}?${apiParams.toString()}`;
+
+  try {
+    const response = await fetch(apiUrl, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json'
+      }
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return errorResponse(
+        errorText || `API request failed with status: ${response.status}`,
+        response.status
+      );
+    }
+
+    const responseText = await response.text();
+
+    return NextResponse.json(JSON.parse(responseText));
+  } catch (error) {
+    return errorResponse((error as Error).message, 500);
+  }
+}
+
+export async function POST(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const limit = searchParams.get('limit') || '20';
+
+  if (Settings.commerceUrl === 'default') {
+    return errorResponse('Commerce URL is not configured', 500);
+  }
+
+  let requestBody;
+  try {
+    requestBody = await request.json();
+  } catch (error) {
+    return errorResponse('Invalid JSON in request body', 400);
+  }
+
+  if (!requestBody.image) {
+    return errorResponse('Image data is required in request body', 400);
+  }
+
+  const apiParams = new URLSearchParams();
+  apiParams.append('limit', limit);
+
+  const apiUrl = `${IMAGE_SEARCH_API_URL}?${apiParams.toString()}`;
+
+  const bodyData: any = { image: requestBody.image };
+
+  if (requestBody.excluded_product_ids) {
+    bodyData.excluded_product_ids = requestBody.excluded_product_ids;
+  }
+
+  try {
+    const response = await fetch(apiUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      body: JSON.stringify(bodyData)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return errorResponse(
+        errorText || `API request failed with status: ${response.status}`,
+        response.status
+      );
+    }
+
+    const responseData = await response.json();
+    return NextResponse.json(responseData);
+  } catch (error) {
+    return errorResponse((error as Error).message, 500);
+  }
+}

package/api/virtual-try-on.ts

@@ -0,0 +1,382 @@
+import { NextRequest, NextResponse } from 'next/server';
+import Settings from 'settings';
+
+const VIRTUAL_TRY_ON_API_URL = process.env.NEXT_PUBLIC_VIRTUAL_TRY_ON_API_URL;
+
+let limitedCategoriesCache: {
+  data: any;
+  timestamp: number;
+} | null = null;
+
+const CACHE_TTL = 3600000;
+
+function getClientIP(request: NextRequest): string | null {
+  const forwardedFor = request.headers.get('x-forwarded-for');
+  if (forwardedFor) {
+    const ip = forwardedFor.split(',')[0].trim();
+    if (ip === '::1' || ip === '::ffff:127.0.0.1') {
+      return '127.0.0.1';
+    }
+    return ip;
+  }
+
+  const realIP = request.headers.get('x-real-ip');
+  if (realIP) {
+    if (realIP === '::1' || realIP === '::ffff:127.0.0.1') {
+      return '127.0.0.1';
+    }
+    return realIP;
+  }
+
+  if (process.env.NODE_ENV === 'development') {
+    return '127.0.0.1';
+  }
+
+  return null;
+}
+
+function getLocaleFromRequest(request: NextRequest): string | null {
+  const cookieLocale = request.cookies.get('pz-locale')?.value;
+
+  if (cookieLocale) {
+    const currentLocale = Settings.localization.locales.find(
+      (l) => l.value === cookieLocale
+    );
+    return currentLocale?.apiValue || null;
+  }
+
+  return null;
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const endpoint = searchParams.get('endpoint');
+
+    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 headersToSend = {
+        Accept: '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: 'GET',
+        headers: headersToSend
+      });
+
+      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',
+          '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'
+        }
+      });
+    } else if (endpoint === 'job-status') {
+      const referenceUrl = searchParams.get('reference_url');
+      if (!referenceUrl) {
+        return NextResponse.json(
+          { error: 'reference_url is required' },
+          { status: 400 }
+        );
+      }
+
+      const externalUrl = `${VIRTUAL_TRY_ON_API_URL}/api/async/v1/job-status?reference_url=${encodeURIComponent(
+        referenceUrl
+      )}`;
+      const clientIP = getClientIP(request);
+      const locale = getLocaleFromRequest(request);
+
+      const headersToSend = {
+        Accept: '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: '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'
+        }
+      });
+    }
+
+    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.';
+      }
+
+      return NextResponse.json(
+        {
+          ...responseData,
+          message: userFriendlyMessage
+        },
+        {
+          status: response.status,
+          headers: {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'POST, OPTIONS',
+            'Access-Control-Allow-Headers':
+              'Content-Type, Accept, Authorization'
+          }
+        }
+      );
+    }
+
+    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,
+      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'
+    }
+  });
+}

package/assets/styles/index.scss

@@ -51,3 +51,87 @@
     z-index: 1001;
   }
 }
+
+.container-droppable {
+  outline: 2px dashed #4482ff !important;
+  outline-offset: -2px;
+  background-color: rgba(96, 165, 250, 0.1) !important;
+}
+
+.container-dragover {
+  background-color: rgba(59, 130, 246, 0.1);
+}
+
+.container-dragover::after {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  border: 2px solid #4482ff;
+  pointer-events: none;
+}
+
+.dragging * {
+  cursor: default !important;
+}
+
+.dragging [data-component='true'] {
+  cursor: grabbing !important;
+}
+
+.dragging .drop-target {
+  cursor: grab !important;
+  outline: 2px dashed #4482ff !important;
+  outline-offset: -2px;
+}
+
+.dragging .no-drop-target {
+  cursor: no-drop !important;
+  outline: 2px dashed #e63946 !important;
+  outline-offset: -2px;
+}
+
+[data-component='true'] {
+  cursor: pointer;
+}
+
+.carousel-container {
+  li[aria-hidden='false'] {
+    div {
+      display: block;
+    }
+  }
+}
+
+.posts-slider-carousel {
+  width: 100%;
+
+  .react-multi-carousel-track {
+    align-items: stretch;
+  }
+}
+
+.posts-slider-dots {
+  position: relative;
+  display: flex;
+  justify-content: center;
+  gap: 8px;
+  margin-top: 16px;
+  padding: 0;
+  list-style: none;
+}
+
+.posts-slider-dots li button {
+  width: 8px;
+  height: 8px;
+  border-radius: 9999px;
+  border: none;
+  background: rgba(0, 0, 0, 0.25);
+  cursor: pointer;
+}
+
+.posts-slider-dots li.react-multi-carousel-dot--active button {
+  background: rgba(0, 0, 0, 0.6);
+}

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  presets: [
+    ['@babel/preset-env', { targets: { node: 'current' } }],
+    '@babel/preset-typescript'
+  ]
+};