@akinon/next 2.0.0-beta.12 → 2.0.0-beta.13

package/api/cache.ts

@@ -21,20 +21,56 @@ async function handleRequest(...args) {
   }
 
   const formData = await req.formData();
-  const body = {} as { key: string; value?: string; expire?: number };
+  const body = {} as {
+    key: string;
+    value?: string;
+    expire?: number;
+    keyValuePairs?: string;
+    compressed?: string;
+  };
 
   formData.forEach((value, key) => {
     body[key] = value;
   });
 
-  const { key, value, expire } = body;
-  let response: string | boolean;
+  const { key, value, expire, keyValuePairs, compressed } = body;
+  let response: any;
 
   try {
     if (req.method === 'POST') {
-      response = await Cache.get(key);
+      // GET request - check if compressed flag is set
+      if (compressed === 'true') {
+        response = await Cache.getCompressed(key);
+      } else {
+        response = await Cache.get(key);
+      }
     } else if (req.method === 'PUT') {
-      response = await Cache.set(key, value, expire);
+      if (keyValuePairs) {
+        try {
+          const parsedKeyValuePairs = JSON.parse(keyValuePairs);
+          if (
+            typeof parsedKeyValuePairs !== 'object' ||
+            parsedKeyValuePairs === null ||
+            Array.isArray(parsedKeyValuePairs)
+          ) {
+            throw new Error('Invalid keyValuePairs format - must be an object');
+          }
+          response = await Cache.mset(parsedKeyValuePairs, expire);
+        } catch (error) {
+          logger.error('Invalid keyValuePairs in mset request', { error });
+          return NextResponse.json(
+            { error: 'Invalid keyValuePairs format' },
+            { status: 400 }
+          );
+        }
+      } else {
+        // SET request - check if compressed flag is set
+        if (compressed === 'true') {
+          response = await Cache.setCompressed(key, value, expire);
+        } else {
+          response = await Cache.set(key, value, expire);
+        }
+      }
     }
   } catch (error) {
     logger.error(error);

package/api/client.ts

@@ -15,8 +15,8 @@ interface RouteParams {
 }
 
 async function proxyRequest(...args) {
-  const [req, { params }] = args as [req: Request, params: RouteParams];
-  const resolvedParams = await params;
+  const [req, routeContext] = args as [req: Request, { params: Promise<RouteParams['params']> }];
+  const params = await routeContext.params;
   const { searchParams } = new URL(req.url);
   const commerceUrl = settings.commerceUrl;
 
@@ -35,7 +35,7 @@ async function proxyRequest(...args) {
     responseType: 'json'
   };
 
-  const slug = `${resolvedParams.slug.join('/')}/`;
+  const slug = `${params.slug.join('/')}/`;
   const options_ = JSON.parse(
     decodeURIComponent((searchParams.get('options') as string) ?? '{}')
   );

package/api/form.ts

@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getFormData } from '@akinon/next/data/server';
+
+interface FormRouteParams {
+  params: Promise<{
+    id: string[];
+  }>;
+}
+
+interface FormConfig {
+  pk: number;
+  is_active: boolean;
+}
+
+type SubmissionData = Record<string, string | File>;
+
+export async function POST(request: NextRequest, { params }: FormRouteParams) {
+  try {
+    const { id } = await params;
+    const formId = id?.[0];
+
+    if (!formId || isNaN(Number(formId))) {
+      return NextResponse.json(
+        { error: 'Valid form ID is required' },
+        { status: 400 }
+      );
+    }
+
+    const formConfig: FormConfig | null = await getFormData({
+      pk: Number(formId)
+    });
+
+    if (!formConfig || !formConfig.is_active) {
+      return NextResponse.json(
+        { error: 'Form not found or inactive' },
+        { status: 404 }
+      );
+    }
+
+    const formData = await request.formData();
+    const submissionData: SubmissionData = Object.fromEntries(
+      formData.entries()
+    );
+
+    return await processFormSubmission(formConfig, submissionData);
+  } catch (error) {
+    console.error('Form submission error:', error);
+
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+async function processFormSubmission(
+  formConfig: FormConfig,
+  data: SubmissionData
+) {
+  const backendUrl = process.env.SERVICE_BACKEND_URL;
+  if (!backendUrl) {
+    throw new Error('SERVICE_BACKEND_URL is not defined');
+  }
+
+  const url = `${backendUrl}/forms/${formConfig.pk}/generate`;
+
+  const submissionPayload = {
+    ...data
+  };
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(submissionPayload)
+  });
+
+  const body = await response.text();
+
+  return new NextResponse(body, {
+    status: response.status,
+    headers: {
+      'Content-Type': response.headers.get('content-type') ?? 'application/json'
+    }
+  });
+}

package/api/image-proxy.ts

@@ -0,0 +1,75 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+async function proxyImage(imageUrl: string) {
+  if (!imageUrl) {
+    return NextResponse.json(
+      { success: false, error: 'Missing url parameter' },
+      { status: 400 }
+    );
+  }
+
+  const imageResponse = await fetch(imageUrl);
+
+  if (!imageResponse.ok) {
+    return NextResponse.json(
+      { success: false, error: 'Failed to fetch image from URL' },
+      { status: 400 }
+    );
+  }
+
+  const imageBuffer = await imageResponse.arrayBuffer();
+  const base64Image = Buffer.from(imageBuffer).toString('base64');
+  const contentType = imageResponse.headers.get('content-type') || 'image/jpeg';
+
+  return { base64Image, contentType, imageBuffer };
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const imageUrl = searchParams.get('url');
+
+    const result = await proxyImage(imageUrl!);
+    if (result instanceof NextResponse) {
+      return result;
+    }
+
+    return new NextResponse(result.imageBuffer, {
+      status: 200,
+      headers: {
+        'Content-Type': result.contentType,
+        'Access-Control-Allow-Origin': '*',
+        'Cache-Control': 'public, max-age=3600'
+      }
+    });
+  } catch (error) {
+    console.error('Image proxy error:', error);
+    return NextResponse.json(
+      { success: false, error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const imageUrl = body.imageUrl;
+
+    const result = await proxyImage(imageUrl);
+    if (result instanceof NextResponse) {
+      return result;
+    }
+
+    return NextResponse.json({
+      success: true,
+      base64Image: `data:${result.contentType};base64,${result.base64Image}`
+    });
+  } catch (error) {
+    console.error('Image proxy POST error:', error);
+    return NextResponse.json(
+      { success: false, error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}

package/api/product-categories.ts

@@ -0,0 +1,53 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getProductData } from '@akinon/next/data/server';
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const pksParam = searchParams.get('pks');
+
+    if (!pksParam) {
+      return NextResponse.json(
+        { error: 'pks parameter required' },
+        { status: 400 }
+      );
+    }
+
+    const pks = pksParam.split(',').map(Number).filter(Boolean);
+
+    if (pks.length === 0) {
+      return NextResponse.json({ error: 'Invalid pks' }, { status: 400 });
+    }
+
+    const results = await Promise.all(
+      pks.map(async (pk) => {
+        try {
+          const { breadcrumbData } = await getProductData({ pk });
+
+          const categoryIds =
+            breadcrumbData
+              ?.map((item: any) => item.extra_context?.attributes?.category_id)
+              .filter(Boolean) || [];
+
+          return { pk, categoryIds };
+        } catch (error) {
+          console.error(`Error fetching product ${pk}:`, error);
+          return { pk, categoryIds: [] };
+        }
+      })
+    );
+
+    const mapping: Record<string, number[]> = {};
+    results.forEach(({ pk, categoryIds }) => {
+      mapping[String(pk)] = categoryIds;
+    });
+
+    return NextResponse.json(mapping);
+  } catch (error) {
+    console.error('Error in product-categories API:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}

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);
+  }
+}