@cobrastyle/adapter-magento2 1.0.1

package/dist/attribute-labels.d.ts

@@ -0,0 +1,4 @@
+/** Code→label map for the current request's store, cached per store code. */
+export declare function getAttributeLabels(): Promise<ReadonlyMap<string, string>>;
+/** Clear the per-store attribute-label cache (tests / after config changes). */
+export declare function clearAttributeLabelsCache(): void;

package/dist/attribute-labels.js

@@ -0,0 +1,56 @@
+import { graphqlFetch } from "./client";
+import { getConfig } from "./config";
+import * as queries from "./queries";
+// `custom_attributesV2` returns only an attribute's `code`, never its storefront
+// label. The code→label mapping is store-wide (not per product), so we fetch it
+// once per store code and cache it, mirroring store-config.ts. Products then
+// join the label in when mapping their technical attributes.
+const cache = new Map();
+const inflight = new Map();
+function currentStoreCode() {
+    const config = getConfig();
+    let resolved;
+    try {
+        resolved = config.storeResolver?.();
+    }
+    catch {
+        resolved = undefined;
+    }
+    return resolved || config.storeCode || "default";
+}
+/** Code→label map for the current request's store, cached per store code. */
+export async function getAttributeLabels() {
+    const code = currentStoreCode();
+    const cached = cache.get(code);
+    if (cached)
+        return cached;
+    const existing = inflight.get(code);
+    if (existing)
+        return existing;
+    const promise = (async () => {
+        let map = new Map();
+        try {
+            const data = await graphqlFetch(queries.GET_PRODUCT_ATTRIBUTE_LABELS, undefined, { storeCode: code });
+            const m = new Map();
+            for (const item of data.attributesList?.items ?? []) {
+                if (item?.code && item.label)
+                    m.set(item.code, item.label);
+            }
+            map = m;
+        }
+        catch {
+            // Labels are cosmetic — a failed metadata fetch must not break the PDP.
+            // Fall back to an empty map; the mapper then shows raw codes.
+            map = new Map();
+        }
+        cache.set(code, map);
+        return map;
+    })().finally(() => inflight.delete(code));
+    inflight.set(code, promise);
+    return promise;
+}
+/** Clear the per-store attribute-label cache (tests / after config changes). */
+export function clearAttributeLabelsCache() {
+    cache.clear();
+    inflight.clear();
+}

package/dist/cart-errors.d.ts

@@ -0,0 +1,10 @@
+import type { MagentoUserError } from './magento-types';
+/**
+ * `error.name` used for cart user-errors (out of stock, not salable, quantity
+ * exceeds available, …). Upstream layers match on this to tell a *user* error
+ * apart from a stale/invalid cart: a user error means the cart is fine and must
+ * be preserved, not cleared and recreated.
+ */
+export declare const CART_USER_ERROR = "CartUserError";
+/** Wrap a Magento cart `user_error` in a tagged Error. */
+export declare function makeCartUserError(userError: MagentoUserError): Error;

package/dist/cart-errors.js

@@ -0,0 +1,14 @@
+/**
+ * `error.name` used for cart user-errors (out of stock, not salable, quantity
+ * exceeds available, …). Upstream layers match on this to tell a *user* error
+ * apart from a stale/invalid cart: a user error means the cart is fine and must
+ * be preserved, not cleared and recreated.
+ */
+export const CART_USER_ERROR = 'CartUserError';
+/** Wrap a Magento cart `user_error` in a tagged Error. */
+export function makeCartUserError(userError) {
+    const err = new Error(userError.message || 'This item could not be added to the cart.');
+    err.name = CART_USER_ERROR;
+    err.code = userError.code;
+    return err;
+}

package/dist/client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Thrown when the GraphQL endpoint rejects a request with HTTP 401. Carries the
+ * status so callers can distinguish an expired/invalid customer token from other
+ * failures and react (e.g. clear the token cookie and fall back to guest).
+ */
+export declare class GraphQLAuthError extends Error {
+    readonly status: 401;
+    constructor(message: string);
+}
+export interface GraphQLClientOptions {
+    customerToken?: string;
+    storeCode?: string;
+    /**
+     * Cache behavior for this request (Next.js cache options)
+     * - 'force-cache': Cache indefinitely (default for GET-like queries)
+     * - 'no-store': Skip cache entirely (for mutations or user-specific data)
+     * - number: Revalidate after N seconds
+     *
+     * NOTE: Mutations and authenticated requests are NEVER cached, regardless of this setting.
+     */
+    cache?: 'force-cache' | 'no-store' | number;
+    /** Tags for on-demand cache revalidation */
+    tags?: string[];
+    /** Request timeout in milliseconds. Defaults to 30000 (30s). */
+    timeout?: number;
+}
+/**
+ * Resolve the store code for a request. Precedence:
+ * explicit option > per-request resolver > config default > "default".
+ * Never throws (a resolver that throws is treated as "no value").
+ */
+export declare function resolveStoreCode(optionStoreCode: string | undefined, resolver: (() => string | undefined) | undefined, configStoreCode: string | undefined): string;
+/**
+ * Append the store code to the request URL so Next's fetch data cache keys
+ * distinctly per store (Magento ignores the extra query param). Prevents
+ * identical queries across stores from colliding in the cache.
+ */
+export declare function cacheScopedUrl(baseUrl: string, storeCode: string): string;
+export declare function graphqlFetch<T>(query: string, variables?: Record<string, unknown>, options?: GraphQLClientOptions): Promise<T>;

package/dist/client.js

@@ -0,0 +1,337 @@
+import { getConfig } from './config';
+import { logger } from './logger';
+/**
+ * Thrown when the GraphQL endpoint rejects a request with HTTP 401. Carries the
+ * status so callers can distinguish an expired/invalid customer token from other
+ * failures and react (e.g. clear the token cookie and fall back to guest).
+ */
+export class GraphQLAuthError extends Error {
+    status = 401;
+    constructor(message) {
+        super(message);
+        this.name = 'GraphQLAuthError';
+    }
+}
+// Sensitive fields that should never be logged
+const SENSITIVE_FIELDS = new Set([
+    'password',
+    'currentPassword',
+    'newPassword',
+    'confirmPassword',
+    'token',
+    'customerToken',
+    'authToken',
+    'accessToken',
+    'refreshToken',
+    'creditCard',
+    'cardNumber',
+    'cvv',
+    'cvc',
+    'securityCode',
+    'ssn',
+    'socialSecurityNumber',
+    'secret',
+    'apiKey',
+    'apiSecret',
+    'pin',
+    'otp',
+    'mfaCode',
+    'twoFactorCode',
+]);
+/**
+ * Recursively redact sensitive fields from an object for safe logging.
+ * Creates a deep copy - does not mutate the original.
+ */
+function redactSensitiveData(data) {
+    if (data === null || data === undefined)
+        return data;
+    if (typeof data !== 'object')
+        return data;
+    if (Array.isArray(data)) {
+        return data.map(item => redactSensitiveData(item));
+    }
+    const redacted = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (SENSITIVE_FIELDS.has(key) || SENSITIVE_FIELDS.has(key.toLowerCase())) {
+            redacted[key] = '[REDACTED]';
+        }
+        else if (typeof value === 'object' && value !== null) {
+            redacted[key] = redactSensitiveData(value);
+        }
+        else {
+            redacted[key] = value;
+        }
+    }
+    return redacted;
+}
+/**
+ * Validate that a URL is secure (HTTPS) in production environments.
+ * Returns an error message if validation fails, null if valid.
+ */
+function validateSecureUrl(url, allowInsecure) {
+    try {
+        const parsed = new URL(url);
+        const isProduction = process.env.NODE_ENV === 'production';
+        const isDevelopment = process.env.NODE_ENV === 'development';
+        const isLocalhost = ['localhost', '127.0.0.1', '::1'].includes(parsed.hostname);
+        const isPrivateNetwork = /^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)/.test(parsed.hostname);
+        // In production, require HTTPS unless explicitly overridden or localhost/private network
+        if (isProduction && !isLocalhost && !isPrivateNetwork && !allowInsecure && parsed.protocol !== 'https:') {
+            return `Insecure connection blocked: API endpoint must use HTTPS in production`;
+        }
+        // Warn in development about insecure connections (but don't block)
+        if (isDevelopment && !isLocalhost && !isPrivateNetwork && parsed.protocol !== 'https:') {
+            console.warn('[Magento2] WARNING: Using insecure HTTP connection. Use HTTPS in production.');
+        }
+        return null;
+    }
+    catch {
+        return 'Invalid GraphQL endpoint URL';
+    }
+}
+/**
+ * Generate a unique request ID for tracing.
+ */
+function generateRequestId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 10);
+    return `mg2-${timestamp}-${random}`;
+}
+// Extract operation name from GraphQL query
+const extractOperationName = (query) => {
+    const match = query.match(/(?:query|mutation)\s+(\w+)/);
+    return match?.[1] ?? 'Anonymous';
+};
+// Check if the query is a mutation
+const isMutation = (query) => {
+    return /^\s*mutation\s/i.test(query.trim());
+};
+const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * Resolve the store code for a request. Precedence:
+ * explicit option > per-request resolver > config default > "default".
+ * Never throws (a resolver that throws is treated as "no value").
+ */
+export function resolveStoreCode(optionStoreCode, resolver, configStoreCode) {
+    let resolved;
+    try {
+        resolved = resolver?.();
+    }
+    catch {
+        resolved = undefined;
+    }
+    return optionStoreCode || resolved || configStoreCode || "default";
+}
+/**
+ * Append the store code to the request URL so Next's fetch data cache keys
+ * distinctly per store (Magento ignores the extra query param). Prevents
+ * identical queries across stores from colliding in the cache.
+ */
+export function cacheScopedUrl(baseUrl, storeCode) {
+    const sep = baseUrl.includes("?") ? "&" : "?";
+    return `${baseUrl}${sep}store=${encodeURIComponent(storeCode)}`;
+}
+export async function graphqlFetch(query, variables, options = {}) {
+    const config = getConfig();
+    const storeCode = resolveStoreCode(options.storeCode, config.storeResolver, config.storeCode);
+    const operationName = extractOperationName(query);
+    const startTime = performance.now();
+    const timeoutMs = options.timeout ?? config.timeout ?? DEFAULT_TIMEOUT_MS;
+    const isDev = process.env.NODE_ENV === 'development';
+    // Validate URL security in production
+    const urlError = validateSecureUrl(config.baseUrl, config.allowInsecure);
+    if (urlError) {
+        throw new Error(urlError);
+    }
+    // Log the outgoing request with sensitive data redacted
+    logger.request(query, redactSensitiveData(variables), {
+        storeCode,
+        hasAuth: !!options.customerToken,
+    });
+    const requestId = generateRequestId();
+    const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'Store': storeCode,
+        // Security headers
+        'X-Request-ID': requestId,
+        'X-Requested-With': 'XMLHttpRequest',
+        // Prevent MIME type sniffing
+        'X-Content-Type-Options': 'nosniff',
+    };
+    // Add any custom headers from config
+    if (config.headers) {
+        Object.assign(headers, config.headers);
+    }
+    if (options.customerToken) {
+        // Validate token format (basic sanity check)
+        if (typeof options.customerToken !== 'string' || options.customerToken.length === 0) {
+            throw new Error('Invalid customer token: token must be a non-empty string');
+        }
+        headers['Authorization'] = `Bearer ${options.customerToken}`;
+    }
+    // Build Next.js cache options
+    const nextOptions = {};
+    // NEVER cache:
+    // 1. Mutations (side effects)
+    // 2. Authenticated requests (user-specific data)
+    // 3. Explicitly disabled cache
+    const isQueryMutation = isMutation(query);
+    const isAuthenticated = !!options.customerToken;
+    const isExplicitNoStore = options.cache === 'no-store';
+    const shouldCache = !isQueryMutation && !isAuthenticated && !isExplicitNoStore;
+    if (shouldCache) {
+        if (typeof options.cache === 'number') {
+            nextOptions.revalidate = options.cache;
+        }
+        else if (options.cache !== 'no-store') {
+            // Default: revalidate every 60 seconds for non-authenticated requests
+            nextOptions.revalidate = 60;
+        }
+        nextOptions.tags = [`store:${storeCode}`, ...(options.tags ?? [])];
+    }
+    const body = JSON.stringify({ query, variables });
+    // Handle SSL verification for local development against self-signed certs.
+    // Hard-guarded to non-production so a stray SKIP_SSL can never weaken TLS in
+    // production. Node reads NODE_TLS_REJECT_UNAUTHORIZED per TLS connection, so
+    // setting it here takes effect for the fetch below.
+    if (config.skipSsl && process.env.NODE_ENV !== 'production') {
+        if (process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0') {
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            console.warn('[Magento2] TLS certificate verification disabled (SKIP_SSL). Development only — never enable in production.');
+        }
+    }
+    // Retry only side-effect-free queries: replaying a mutation could double-add
+    // to cart, place duplicate orders, etc. Mutations get a single attempt.
+    const maxAttempts = isQueryMutation ? 1 : Math.max(1, (config.maxRetries ?? 2) + 1);
+    const baseDelayMs = config.retryDelayMs ?? 150;
+    let lastError;
+    // A 401 on an authenticated request means the customer token expired. We give
+    // the app one chance to swap in a fresh token (via config.tokenRefresher) and
+    // replay the request. Guarded to a single attempt so a persistently rejected
+    // token can't loop forever.
+    let authRefreshed = false;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const isLastAttempt = attempt === maxAttempts;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const fetchOptions = {
+            method: 'POST',
+            headers,
+            body,
+            signal: controller.signal,
+            ...(shouldCache && Object.keys(nextOptions).length > 0 && { next: nextOptions }),
+            ...(!shouldCache && { cache: 'no-store' }),
+        };
+        try {
+            const response = await fetch(cacheScopedUrl(config.baseUrl, storeCode), fetchOptions);
+            const duration = Math.round(performance.now() - startTime);
+            // Helper for safe error messages (show URL only in dev)
+            const safeUrl = isDev ? config.baseUrl : 'GraphQL endpoint';
+            if (!response.ok) {
+                const text = await response.text();
+                // Transient server errors (5xx) are safe to retry for queries.
+                if (response.status >= 500 && !isLastAttempt) {
+                    logger.error(operationName, new Error(`HTTP ${response.status} (attempt ${attempt}/${maxAttempts}), retrying`), duration);
+                    await delay(backoffMs(baseDelayMs, attempt));
+                    continue;
+                }
+                // An authenticated request rejected with 401 usually means the customer
+                // token expired. Ask the app to refresh it once, then replay with the
+                // fresh token. A 401 means the server never processed the request, so
+                // replaying is safe even for mutations (nothing was mutated).
+                if (response.status === 401 &&
+                    !authRefreshed &&
+                    options.customerToken &&
+                    config.tokenRefresher) {
+                    authRefreshed = true;
+                    const freshToken = await config.tokenRefresher();
+                    if (freshToken) {
+                        headers['Authorization'] = `Bearer ${freshToken}`;
+                        logger.error(operationName, new Error(`HTTP 401, refreshed token and retrying [${requestId}]`), duration);
+                        attempt--; // don't consume a transient-retry attempt
+                        continue;
+                    }
+                }
+                logger.error(operationName, new Error(`HTTP ${response.status}: ${text}`), duration);
+                if (response.status === 401) {
+                    throw new GraphQLAuthError(`GraphQL request failed: 401 ${response.statusText} [${requestId}]`);
+                }
+                throw new Error(`GraphQL request failed: ${response.status} ${response.statusText} [${requestId}]`);
+            }
+            const text = await response.text();
+            // Check if response is HTML (likely an error page)
+            if (text.trim().startsWith('<!') || text.trim().startsWith('<html')) {
+                logger.error(operationName, new Error(`Received HTML instead of JSON. URL: ${config.baseUrl}`), duration);
+                throw new Error(`${safeUrl} returned HTML instead of JSON [${requestId}]`);
+            }
+            // Check if response is empty
+            if (!text.trim()) {
+                logger.error(operationName, new Error(`Empty response from ${config.baseUrl}`), duration);
+                throw new Error(`Empty response from ${safeUrl} [${requestId}]`);
+            }
+            let json;
+            try {
+                json = JSON.parse(text);
+            }
+            catch (parseError) {
+                logger.error(operationName, new Error(`Invalid JSON: ${text.substring(0, 200)}`), duration);
+                throw new Error(`${safeUrl} returned invalid JSON [${requestId}]`);
+            }
+            if (json.errors && json.errors.length > 0) {
+                const messages = json.errors.map((e) => e.message).join(', ');
+                logger.error(operationName, new Error(messages), duration);
+                throw new Error(`GraphQL errors: ${messages} [${requestId}]`);
+            }
+            if (!json.data) {
+                logger.error(operationName, new Error('No data returned'), duration);
+                throw new Error(`No data returned from GraphQL [${requestId}]`);
+            }
+            // Log successful response
+            logger.response(operationName, json.data, duration);
+            return json.data;
+        }
+        catch (error) {
+            const duration = Math.round(performance.now() - startTime);
+            const isTimeout = error instanceof DOMException && error.name === 'AbortError';
+            // A raw fetch failure (DNS, connection reset/refused) surfaces as a
+            // TypeError before the request reaches the server, so it's safe to retry.
+            const isNetworkError = error instanceof TypeError;
+            // Retry transient transport failures for side-effect-free queries only.
+            if ((isTimeout || isNetworkError) && !isLastAttempt) {
+                lastError = error;
+                logger.error(operationName, new Error(`${isTimeout ? `Timeout after ${timeoutMs}ms` : 'Network error'} (attempt ${attempt}/${maxAttempts}), retrying`), duration);
+                await delay(backoffMs(baseDelayMs, attempt));
+                continue;
+            }
+            if (isTimeout) {
+                logger.error(operationName, new Error(`Request timed out after ${timeoutMs}ms`), duration);
+                throw new Error(`GraphQL request timed out after ${timeoutMs}ms for ${operationName} [${requestId}]`);
+            }
+            if (!(error instanceof Error && error.message.includes('GraphQL'))) {
+                // Only log if not already logged above
+                logger.error(operationName, error, duration);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    // Unreachable in practice: the loop either returns or throws. Rethrow the
+    // last transport error as a defensive fallback for the type checker.
+    throw lastError instanceof Error
+        ? lastError
+        : new Error(`GraphQL request failed after ${maxAttempts} attempts for ${operationName} [${requestId}]`);
+}
+/** Sleep helper for retry backoff. */
+function delay(ms) {
+    return ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+}
+/** Exponential backoff with jitter, capped at 2s. */
+function backoffMs(base, attempt) {
+    if (base <= 0)
+        return 0;
+    const exp = Math.min(2000, base * 2 ** (attempt - 1));
+    return exp + Math.floor(Math.random() * base);
+}

package/dist/config.d.ts

@@ -0,0 +1,52 @@
+import type { AdapterConfig } from '@cobrastyle/shared-types';
+import type { GraphQLClientOptions } from './client';
+export interface MagentoConfig extends AdapterConfig {
+    baseUrl: string;
+    storeCode?: string;
+    skipSsl?: boolean;
+    timeout?: number;
+    rootCategoryId?: number;
+    /**
+     * Number of times to retry a *side-effect-free* query after a transient
+     * failure (network error, timeout, or 5xx). Mutations are never retried.
+     * @default 2
+     */
+    maxRetries?: number;
+    /**
+     * Base backoff in milliseconds between retries (grows exponentially with a
+     * little jitter). Set to 0 to disable the delay (used in tests).
+     * @default 150
+     */
+    retryDelayMs?: number;
+    /**
+     * Allow insecure (HTTP) connections.
+     * WARNING: Only use in development! Never enable in production.
+     * @default false
+     */
+    allowInsecure?: boolean;
+    /** Callback to retrieve the current customer token (e.g. from cookies). */
+    customerTokenGetter?: () => Promise<string | undefined>;
+    /**
+     * Callback invoked when an authenticated request is rejected with HTTP 401
+     * (expired customer token). Should attempt to mint a fresh access token
+     * (e.g. via a refresh token) and return it, or return undefined if the
+     * session can't be recovered. The client replays the failed request once
+     * with the returned token.
+     */
+    tokenRefresher?: () => Promise<string | undefined>;
+    /**
+     * Callback returning the store code for the current request (e.g. read from a
+     * request header the app set from the URL). Used to scope the `Store` header
+     * per request. Returns undefined outside a request; resolution then falls
+     * back to `storeCode`.
+     */
+    storeResolver?: () => string | undefined;
+}
+export declare const getConfig: () => MagentoConfig;
+export declare const setConfig: (newConfig: Partial<MagentoConfig>) => void;
+export declare const createConfig: (overrides?: Partial<MagentoConfig>) => MagentoConfig;
+/**
+ * Build GraphQL client options with the customer token if available.
+ * Merges with any extra options passed in.
+ */
+export declare function withCustomerAuth(extra?: GraphQLClientOptions): Promise<GraphQLClientOptions>;

package/dist/config.js

@@ -0,0 +1,28 @@
+let config = {
+    baseUrl: process.env.MAGENTO_URL || 'https://magento.example.com/graphql',
+    storeCode: process.env.MAGENTO_STORE || 'default',
+    skipSsl: process.env.SKIP_SSL === 'true',
+    allowInsecure: process.env.ALLOW_INSECURE === 'true',
+    timeout: 30000,
+    // If not set, will be fetched dynamically from storeConfig
+    rootCategoryId: process.env.MAGENTO_ROOT_CATEGORY_ID ? parseInt(process.env.MAGENTO_ROOT_CATEGORY_ID, 10) : undefined,
+};
+export const getConfig = () => config;
+export const setConfig = (newConfig) => {
+    config = { ...config, ...newConfig };
+};
+export const createConfig = (overrides = {}) => ({
+    ...config,
+    ...overrides,
+});
+/**
+ * Build GraphQL client options with the customer token if available.
+ * Merges with any extra options passed in.
+ */
+export async function withCustomerAuth(extra = {}) {
+    const token = await config.customerTokenGetter?.();
+    if (token) {
+        return { ...extra, customerToken: token };
+    }
+    return extra;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { magento2Adapter, magento2Adapter as default } from './adapter';
+export { getConfig, setConfig, createConfig, withCustomerAuth } from './config';
+export type { MagentoConfig } from './config';
+export { graphqlFetch, GraphQLAuthError } from './client';
+export { logger, MagentoLogger } from './logger';
+export * as queries from './queries';
+export * as mappers from './mappers';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { magento2Adapter, magento2Adapter as default } from './adapter';
+export { getConfig, setConfig, createConfig, withCustomerAuth } from './config';
+export { graphqlFetch, GraphQLAuthError } from './client';
+export { logger, MagentoLogger } from './logger';
+export * as queries from './queries';
+export * as mappers from './mappers';

package/dist/logger.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Magento2 Adapter Logger
+ *
+ * A clear, colorful logger for tracking GraphQL requests and responses.
+ * Enable/disable via MAGENTO_DEBUG environment variable.
+ */
+interface LogOptions {
+    showVariables?: boolean;
+    showFullQuery?: boolean;
+    showResponseData?: boolean;
+    showFullResponse?: boolean;
+    maxDataLength?: number;
+}
+declare class MagentoLogger {
+    private requestCount;
+    private options;
+    constructor(options?: LogOptions);
+    private log;
+    private getPrefix;
+    /**
+     * Log an outgoing GraphQL request
+     */
+    request(query: string, variables?: Record<string, unknown>, meta?: {
+        storeCode?: string;
+        hasAuth?: boolean;
+    }): void;
+    /**
+     * Log a successful response
+     */
+    response(operationName: string, data: unknown, duration: number): void;
+    /**
+     * Log an error response
+     */
+    error(operationName: string, error: unknown, duration?: number): void;
+    /**
+     * Generate a preview of response data
+     */
+    private getDataPreview;
+    /**
+     * Log general info
+     */
+    info(message: string, data?: unknown): void;
+    /**
+     * Log a warning
+     */
+    warn(message: string, data?: unknown): void;
+    /**
+     * Get request statistics
+     */
+    getStats(): {
+        totalRequests: number;
+    };
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+}
+export declare const logger: MagentoLogger;
+export { MagentoLogger };