@akinon/next 2.0.6-rc.1 → 2.0.6

package/data/server/special-page.ts

@@ -4,9 +4,6 @@ import { GetCategoryResponse, SearchParams } from '../../types';
 import { generateCommerceSearchParams } from '../../utils';
 import appFetch from '../../utils/app-fetch';
 import { ServerVariables } from '../../utils/server-variables';
-import { optimizeCategoryResponse } from '../../utils/payload-optimizer';
-import logger from '../../utils/log';
-import settings from 'settings';
 
 const getSpecialPageDataHandler = (
   pk: number,
@@ -48,7 +45,7 @@ export const getSpecialPageData = async ({
   searchParams: SearchParams;
   headers?: Record<string, string>;
 }) => {
-  const result = await Cache.wrap(
+  return Cache.wrap(
     CacheKey.SpecialPage(pk, searchParams, headers),
     locale,
     getSpecialPageDataHandler(pk, locale, currency, searchParams, headers),
@@ -57,14 +54,4 @@ export const getSpecialPageData = async ({
       compressed: true
     }
   );
-
-  if (settings.payloadOptimization?.enabled && result) {
-    try {
-      return optimizeCategoryResponse(result, settings.payloadOptimization);
-    } catch (e) {
-      logger.error('Payload optimization failed for special-page', { pk, error: (e as Error).message });
-    }
-  }
-
-  return result;
 };

package/data/server/widget.ts

@@ -4,9 +4,6 @@ import { CacheOptions, WidgetResultType, WidgetSchemaType } from '../../types';
 import appFetch from '../../utils/app-fetch';
 import { widgets } from '../urls';
 import { ServerVariables } from '../../utils/server-variables';
-import { optimizeWidgetResponse } from '../../utils/payload-optimizer';
-import logger from '../../utils/log';
-import settings from 'settings';
 
 const getWidgetDataHandler =
   (
@@ -56,7 +53,7 @@ export const getWidgetData = async <T>({
   cacheOptions?: CacheOptions;
   headers?: Record<string, string>;
 }): Promise<WidgetResultType<T>> => {
-  const result = await Cache.wrap(
+  return Cache.wrap(
     CacheKey.Widget(slug),
     locale,
     getWidgetDataHandler(slug, locale, currency, headers),
@@ -65,16 +62,6 @@ export const getWidgetData = async <T>({
       ...cacheOptions
     }
   );
-
-  if (settings.payloadOptimization?.enabled && result) {
-    try {
-      return optimizeWidgetResponse(result, settings.payloadOptimization) as WidgetResultType<T>;
-    } catch (e) {
-      logger.error('Payload optimization failed for widget', { slug, error: (e as Error).message });
-    }
-  }
-
-  return result as WidgetResultType<T>;
 };
 
 const getCollectionWidgetDataHandler =

package/data/urls.ts

@@ -183,11 +183,7 @@ export const product = {
   breadcrumbUrl: (menuitemmodel: string) =>
     `/menus/generate_breadcrumb/?item=${menuitemmodel}&generator_name=menu_item`,
   bundleProduct: (productPk: string, queryString: string) =>
-    `/bundle-product/${productPk}/?${queryString}`,
-  similarProducts: (params?: string) =>
-    `/similar-products${params ? `?${params}` : ''}`,
-  similarProductsList: (params?: string) =>
-    `/similar-product-list${params ? `?${params}` : ''}`
+    `/bundle-product/${productPk}/?${queryString}`
 };
 
 export const wishlist = {

package/hooks/index.ts

@@ -14,3 +14,4 @@ export * from './use-logger';
 export * from './use-logger-context';
 export * from './use-sentry-uncaught-errors';
 export * from './use-pz-params';
+export * from './use-toast';

package/hooks/use-captcha.tsx

@@ -39,7 +39,7 @@ export const useCaptcha = () => {
   };
 
   if (csrfToken) {
-    setCookie('csrftoken', csrfToken, { secure: true });
+    setCookie('csrftoken', csrfToken);
   }
 
   const onCaptchaChange = useCallback(async (response) => {

package/hooks/use-toast.ts

@@ -0,0 +1,56 @@
+'use client'
+
+import { useCallback } from 'react'
+import { useAppDispatch } from '../redux/hooks'
+import {
+  addToast,
+  removeToast,
+  ToastType,
+  ToastInput
+} from '../redux/reducers/toast'
+
+export type ToastOptions = Omit<ToastInput, 'type' | 'message'>
+
+export const useToast = () => {
+  const dispatch = useAppDispatch()
+
+  const toast = useCallback(
+    (type: ToastType, message: string, options?: ToastOptions) => {
+      dispatch(addToast({ type, message, ...options }))
+    },
+    [dispatch]
+  )
+
+  const success = useCallback(
+    (message: string, options?: ToastOptions) =>
+      toast('success', message, options),
+    [toast]
+  )
+
+  const error = useCallback(
+    (message: string, options?: ToastOptions) =>
+      toast('error', message, options),
+    [toast]
+  )
+
+  const warning = useCallback(
+    (message: string, options?: ToastOptions) =>
+      toast('warning', message, options),
+    [toast]
+  )
+
+  const info = useCallback(
+    (message: string, options?: ToastOptions) =>
+      toast('info', message, options),
+    [toast]
+  )
+
+  const dismiss = useCallback(
+    (id: string) => {
+      dispatch(removeToast(id))
+    },
+    [dispatch]
+  )
+
+  return { toast, success, error, warning, info, dismiss }
+}

package/instrumentation/index.ts

@@ -3,6 +3,7 @@ import * as Sentry from '@sentry/nextjs';
 
 export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
+    await import('./node');
     initSentry('Server');
   }
 

package/instrumentation/node.ts

@@ -1,2 +1,224 @@
-// OpenTelemetry tracing is handled by Sentry.
-// Custom NodeSDK setup removed due to version incompatibility with Sentry 10's OpenTelemetry v2.x requirements.
+import { context, trace, type SpanAttributes } from '@opentelemetry/api';
+import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
+import { ExportResultCode, type ExportResult } from '@opentelemetry/core';
+import {
+  BasicTracerProvider,
+  SimpleSpanProcessor,
+  type ReadableSpan,
+  type SpanExporter
+} from '@opentelemetry/sdk-trace-base';
+
+type OTelAttributeValue =
+  | { stringValue: string }
+  | { intValue: number }
+  | { doubleValue: number }
+  | { boolValue: boolean };
+
+const PZ_DASHBOARD_TRACING_STARTED_KEY = '__pzDashboardTracingStarted__';
+const SERVICE_NAME = 'pz-next-app';
+const DASHBOARD_FALLBACK_URL = 'http://localhost:3005';
+
+type PzDashboardGlobal = typeof globalThis & {
+  [PZ_DASHBOARD_TRACING_STARTED_KEY]?: boolean;
+};
+
+const getDashboardTraceUrl = () => {
+  const baseUrl = process.env.PZ_DASHBOARD_URL ?? DASHBOARD_FALLBACK_URL;
+
+  return `${baseUrl.replace(/\/$/, '')}/api/traces`;
+};
+
+const hrTimeToUnixNano = ([seconds, nanos]: [number, number]) =>
+  (BigInt(seconds) * BigInt(1000000000) + BigInt(nanos)).toString();
+
+const getAttributeValue = (value: unknown): OTelAttributeValue => {
+  if (typeof value === 'string') {
+    return { stringValue: value };
+  }
+
+  if (typeof value === 'number') {
+    return Number.isInteger(value)
+      ? { intValue: value }
+      : { doubleValue: value };
+  }
+
+  if (typeof value === 'boolean') {
+    return { boolValue: value };
+  }
+
+  return { stringValue: JSON.stringify(value ?? '') };
+};
+
+const getAttributes = (attributes: SpanAttributes = {}) =>
+  Object.entries(attributes)
+    .filter(([, value]) => value !== undefined)
+    .map(([key, value]) => ({
+      key,
+      value: getAttributeValue(value)
+    }));
+
+const getParentSpanId = (span: ReadableSpan) => {
+  if ('parentSpanId' in span && typeof span.parentSpanId === 'string') {
+    return span.parentSpanId;
+  }
+
+  if (
+    'parentSpanContext' in span &&
+    span.parentSpanContext &&
+    typeof span.parentSpanContext === 'object' &&
+    'spanId' in span.parentSpanContext
+  ) {
+    return String(span.parentSpanContext.spanId);
+  }
+
+  return undefined;
+};
+
+const getResourceAttributes = (span: ReadableSpan) => ({
+  ...(span.resource?.attributes ?? {}),
+  'service.name':
+    process.env.OTEL_SERVICE_NAME ??
+    process.env.NEXT_PUBLIC_APP_NAME ??
+    SERVICE_NAME
+});
+
+const getScope = (span: ReadableSpan) => {
+  const scopedSpan = span as ReadableSpan & {
+    instrumentationLibrary?: {
+      name?: string;
+      version?: string;
+    };
+    instrumentationScope?: {
+      name?: string;
+      version?: string;
+    };
+  };
+  const scope =
+    scopedSpan.instrumentationScope ?? scopedSpan.instrumentationLibrary;
+
+  return {
+    name: scope?.name ?? SERVICE_NAME,
+    version: scope?.version ?? ''
+  };
+};
+
+const getSpanPayload = (span: ReadableSpan) => ({
+  traceId: span.spanContext().traceId,
+  spanId: span.spanContext().spanId,
+  parentSpanId: getParentSpanId(span),
+  name: span.name,
+  kind: span.kind,
+  startTimeUnixNano: hrTimeToUnixNano(span.startTime),
+  endTimeUnixNano: hrTimeToUnixNano(span.endTime),
+  attributes: getAttributes(span.attributes),
+  droppedAttributesCount: span.droppedAttributesCount ?? 0,
+  events:
+    span.events?.map((event) => ({
+      name: event.name,
+      timeUnixNano: hrTimeToUnixNano(event.time),
+      attributes: getAttributes(event.attributes),
+      droppedAttributesCount: event.droppedAttributesCount ?? 0
+    })) ?? [],
+  droppedEventsCount: span.droppedEventsCount ?? 0,
+  status: span.status,
+  links:
+    span.links?.map((link) => ({
+      traceId: link.context.traceId,
+      spanId: link.context.spanId,
+      attributes: getAttributes(link.attributes),
+      droppedAttributesCount: link.droppedAttributesCount ?? 0
+    })) ?? [],
+  droppedLinksCount: span.droppedLinksCount ?? 0
+});
+
+class PzDashboardTraceExporter implements SpanExporter {
+  constructor(private readonly url: string) {}
+
+  export(
+    spans: ReadableSpan[],
+    resultCallback: (result: ExportResult) => void
+  ) {
+    const [firstSpan] = spans;
+
+    if (!firstSpan) {
+      resultCallback({ code: ExportResultCode.SUCCESS });
+      return;
+    }
+
+    void this.sendSpans(spans, firstSpan, resultCallback);
+  }
+
+  private async sendSpans(
+    spans: ReadableSpan[],
+    firstSpan: ReadableSpan,
+    resultCallback: (result: ExportResult) => void
+  ) {
+    try {
+      const response = await fetch(this.url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          resourceSpans: [
+            {
+              resource: {
+                attributes: getAttributes(getResourceAttributes(firstSpan)),
+                droppedAttributesCount: 0
+              },
+              scopeSpans: spans.map((span) => ({
+                scope: getScope(span),
+                spans: [getSpanPayload(span)]
+              }))
+            }
+          ]
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`PZ Dashboard trace export failed: ${response.status}`);
+      }
+
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    } catch (error) {
+      resultCallback({
+        code: ExportResultCode.FAILED,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
+
+  shutdown() {
+    return Promise.resolve();
+  }
+}
+
+const startDashboardTracing = () => {
+  const pzDashboardGlobal = globalThis as PzDashboardGlobal;
+
+  if (pzDashboardGlobal[PZ_DASHBOARD_TRACING_STARTED_KEY]) {
+    return;
+  }
+
+  const provider = new BasicTracerProvider({
+    spanProcessors: [
+      new SimpleSpanProcessor(
+        new PzDashboardTraceExporter(getDashboardTraceUrl())
+      )
+    ]
+  });
+
+  context.setGlobalContextManager(
+    new AsyncLocalStorageContextManager().enable()
+  );
+
+  const registered = trace.setGlobalTracerProvider(provider);
+
+  if (!registered) {
+    return;
+  }
+
+  pzDashboardGlobal[PZ_DASHBOARD_TRACING_STARTED_KEY] = true;
+};
+
+if (process.env.NODE_ENV === 'development') {
+  startDashboardTracing();
+}

package/lib/fixture-manager.ts

@@ -0,0 +1,146 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import * as crypto from 'crypto'
+import logger from '../utils/log'
+
+export const MockMode = {
+  RECORD: 'record',
+  REPLAY: 'replay'
+} as const
+
+export type MockMode = (typeof MockMode)[keyof typeof MockMode]
+
+interface FixtureData {
+  request: {
+    method: string
+    url: string
+    body?: any
+  }
+  response: {
+    status: number
+    headers: Record<string, string>
+    body: any
+  }
+  recorded_at: string
+}
+
+const SENSITIVE_HEADERS = [
+  'authorization',
+  'cookie',
+  'set-cookie',
+  'x-csrftoken',
+  'x-forwarded-for'
+]
+
+class FixtureManager {
+  private fixturesDir: string
+  private dirEnsured = false
+
+  constructor() {
+    this.fixturesDir = path.join(process.cwd(), '.pz-fixtures')
+  }
+
+  private ensureDir(): void {
+    if (this.dirEnsured) return
+    fs.mkdirSync(this.fixturesDir, { recursive: true })
+    this.dirEnsured = true
+  }
+
+  generateKey(method: string, url: string, body?: any): string {
+    const normalized = method?.toUpperCase() ?? 'GET'
+    const parts = [normalized, url]
+
+    if (body && normalized !== 'GET') {
+      const bodyStr =
+        typeof body === 'string' ? body : JSON.stringify(body)
+      parts.push(bodyStr)
+    }
+
+    return crypto.createHash('md5').update(parts.join(':')).digest('hex')
+  }
+
+  extractHeaders(headers: Headers): Record<string, string> {
+    const result: Record<string, string> = {}
+    headers.forEach((value, key) => {
+      result[key] = value
+    })
+    return result
+  }
+
+  private stripSensitiveHeaders(
+    headers: Record<string, string>
+  ): Record<string, string> {
+    const cleaned: Record<string, string> = {}
+
+    for (const [key, value] of Object.entries(headers)) {
+      if (!SENSITIVE_HEADERS.includes(key.toLowerCase())) {
+        cleaned[key] = value
+      }
+    }
+
+    return cleaned
+  }
+
+  async write(
+    method: string,
+    url: string,
+    body: any,
+    response: { status: number; headers: Record<string, string>; body: any }
+  ): Promise<void> {
+    try {
+      this.ensureDir()
+
+      const normalized = method?.toUpperCase() ?? 'GET'
+      const key = this.generateKey(normalized, url, body)
+      const fixture: FixtureData = {
+        request: {
+          method: normalized,
+          url
+        },
+        response: {
+          status: response.status,
+          headers: this.stripSensitiveHeaders(response.headers),
+          body: response.body
+        },
+        recorded_at: new Date().toISOString()
+      }
+
+      if (body && normalized !== 'GET') {
+        fixture.request.body = body
+      }
+
+      const filePath = path.join(this.fixturesDir, `${key}.json`)
+      await fs.promises.writeFile(filePath, JSON.stringify(fixture, null, 2))
+
+      logger.debug(`[pz-mock] Recorded fixture: ${normalized} ${url} → ${filePath}`)
+    } catch (error) {
+      logger.error(`[pz-mock] Failed to write fixture`, { url, error })
+    }
+  }
+
+  async read(
+    method: string,
+    url: string,
+    body?: any
+  ): Promise<{ found: boolean; fixture?: FixtureData }> {
+    try {
+      const key = this.generateKey(method, url, body)
+      const filePath = path.join(this.fixturesDir, `${key}.json`)
+
+      const raw = await fs.promises.readFile(filePath, 'utf-8')
+      const fixture = JSON.parse(raw) as FixtureData
+
+      logger.debug(`[pz-mock] Replaying fixture: ${method} ${url} → ${key}`)
+      return { found: true, fixture }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        logger.warn(`[pz-mock] No fixture found: ${method} ${url}`)
+        return { found: false }
+      }
+      logger.error(`[pz-mock] Failed to read fixture`, { url, error })
+      return { found: false }
+    }
+  }
+}
+
+export const fixtureManager = new FixtureManager()

package/middlewares/default.ts

@@ -547,8 +547,7 @@ const withPzDefault =
                                           'csrftoken',
                                           csrf_token,
                                           {
-                                            domain: rootHostname,
-                                            secure: true
+                                            domain: rootHostname
                                           }
                                         );
                                       }