@cobrastyle/adapter-magento2 1.0.1

package/dist/logger.js

@@ -0,0 +1,258 @@
+/**
+ * Magento2 Adapter Logger
+ *
+ * A clear, colorful logger for tracking GraphQL requests and responses.
+ * Enable/disable via MAGENTO_DEBUG environment variable.
+ */
+// ANSI color codes for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Foreground
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    magenta: '\x1b[35m',
+    blue: '\x1b[34m',
+    gray: '\x1b[90m',
+    white: '\x1b[37m',
+    // Background
+    bgBlue: '\x1b[44m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgRed: '\x1b[41m',
+    bgMagenta: '\x1b[45m',
+};
+const defaultOptions = {
+    showVariables: true,
+    showFullQuery: false,
+    showResponseData: true,
+    showFullResponse: true,
+    maxDataLength: 500,
+};
+// Check if logging is enabled
+const isEnabled = () => {
+    return process.env.MAGENTO_DEBUG === 'true' || process.env.MAGENTO_DEBUG === '1';
+};
+// Extract operation name from GraphQL query
+const extractOperationName = (query) => {
+    const match = query.match(/(?:query|mutation)\s+(\w+)/);
+    return match?.[1] ?? 'Anonymous';
+};
+// Format timestamp
+const timestamp = () => {
+    const now = new Date();
+    return `${colors.gray}${now.toLocaleTimeString('en-US', {
+        hour12: false,
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        fractionalSecondDigits: 3
+    })}${colors.reset}`;
+};
+// Truncate long strings
+const truncate = (str, maxLength) => {
+    if (str.length <= maxLength)
+        return str;
+    return str.substring(0, maxLength) + '...';
+};
+// Format JSON with indentation
+const formatJson = (obj, maxLength) => {
+    const json = JSON.stringify(obj, null, 2);
+    return maxLength ? truncate(json, maxLength) : json;
+};
+// Box drawing characters for pretty output
+const box = {
+    topLeft: '┌',
+    topRight: '┐',
+    bottomLeft: '└',
+    bottomRight: '┘',
+    horizontal: '─',
+    vertical: '│',
+    teeRight: '├',
+    teeLeft: '┤',
+};
+// Draw a horizontal line
+const line = (width = 60) => {
+    return box.horizontal.repeat(width);
+};
+// Main logger class
+class MagentoLogger {
+    requestCount = 0;
+    options;
+    constructor(options = {}) {
+        this.options = { ...defaultOptions, ...options };
+    }
+    log(level, ...args) {
+        if (!isEnabled())
+            return;
+        const prefix = this.getPrefix(level);
+        console.log(prefix, ...args);
+    }
+    getPrefix(level) {
+        const ts = timestamp();
+        switch (level) {
+            case 'request':
+                return `${ts} ${colors.bgBlue}${colors.white} REQ ${colors.reset}`;
+            case 'response':
+                return `${ts} ${colors.bgGreen}${colors.white} RES ${colors.reset}`;
+            case 'error':
+                return `${ts} ${colors.bgRed}${colors.white} ERR ${colors.reset}`;
+            case 'warn':
+                return `${ts} ${colors.bgYellow}${colors.white} WRN ${colors.reset}`;
+            case 'info':
+                return `${ts} ${colors.bgMagenta}${colors.white} INF ${colors.reset}`;
+        }
+    }
+    /**
+     * Log an outgoing GraphQL request
+     */
+    request(query, variables, meta) {
+        if (!isEnabled())
+            return;
+        this.requestCount++;
+        const operationName = extractOperationName(query);
+        console.log('');
+        console.log(`${colors.cyan}${box.topLeft}${line(58)}${box.topRight}${colors.reset}`);
+        this.log('request', `${colors.bright}${colors.cyan}#${this.requestCount} ${operationName}${colors.reset}`);
+        if (meta?.storeCode) {
+            console.log(`${colors.cyan}${box.vertical}${colors.reset}  ${colors.gray}Store:${colors.reset} ${meta.storeCode}`);
+        }
+        if (meta?.hasAuth) {
+            console.log(`${colors.cyan}${box.vertical}${colors.reset}  ${colors.gray}Auth:${colors.reset} ${colors.green}✓ Authenticated${colors.reset}`);
+        }
+        if (this.options.showVariables && variables && Object.keys(variables).length > 0) {
+            console.log(`${colors.cyan}${box.vertical}${colors.reset}  ${colors.gray}Variables:${colors.reset}`);
+            const varLines = formatJson(variables, 300).split('\n');
+            varLines.forEach(line => {
+                console.log(`${colors.cyan}${box.vertical}${colors.reset}    ${colors.yellow}${line}${colors.reset}`);
+            });
+        }
+        if (this.options.showFullQuery) {
+            console.log(`${colors.cyan}${box.vertical}${colors.reset}  ${colors.gray}Query:${colors.reset}`);
+            const queryLines = query.trim().split('\n').slice(0, 10);
+            queryLines.forEach(line => {
+                console.log(`${colors.cyan}${box.vertical}${colors.reset}    ${colors.dim}${line}${colors.reset}`);
+            });
+            if (query.trim().split('\n').length > 10) {
+                console.log(`${colors.cyan}${box.vertical}${colors.reset}    ${colors.dim}... (${query.trim().split('\n').length - 10} more lines)${colors.reset}`);
+            }
+        }
+    }
+    /**
+     * Log a successful response
+     */
+    response(operationName, data, duration) {
+        if (!isEnabled())
+            return;
+        this.log('response', `${colors.bright}${colors.green}${operationName}${colors.reset} ${colors.gray}(${duration}ms)${colors.reset}`);
+        if (this.options.showResponseData && data) {
+            const preview = this.getDataPreview(data);
+            if (preview) {
+                console.log(`${colors.cyan}${box.vertical}${colors.reset}  ${colors.gray}Summary:${colors.reset} ${preview}`);
+            }
+            // Show full response data for inspection
+            if (this.options.showFullResponse) {
+                console.log(`${colors.cyan}${box.vertical}${colors.reset}  ${colors.gray}Response Data:${colors.reset}`);
+                console.log(`${colors.cyan}${box.vertical}${colors.reset}`);
+                // Use console.dir for deep inspection with colors
+                console.dir(data, { depth: null, colors: true });
+                console.log(`${colors.cyan}${box.vertical}${colors.reset}`);
+            }
+        }
+        console.log(`${colors.cyan}${box.bottomLeft}${line(58)}${box.bottomRight}${colors.reset}`);
+        console.log('');
+    }
+    /**
+     * Log an error response
+     */
+    error(operationName, error, duration) {
+        if (!isEnabled())
+            return;
+        const durationStr = duration ? ` ${colors.gray}(${duration}ms)${colors.reset}` : '';
+        this.log('error', `${colors.bright}${colors.red}${operationName}${colors.reset}${durationStr}`);
+        if (error instanceof Error) {
+            console.log(`${colors.cyan}${box.vertical}${colors.reset}  ${colors.red}${error.message}${colors.reset}`);
+        }
+        else {
+            console.log(`${colors.cyan}${box.vertical}${colors.reset}  ${colors.red}${String(error)}${colors.reset}`);
+        }
+        console.log(`${colors.red}${box.bottomLeft}${line(58)}${box.bottomRight}${colors.reset}`);
+        console.log('');
+    }
+    /**
+     * Generate a preview of response data
+     */
+    getDataPreview(data) {
+        if (!data || typeof data !== 'object')
+            return '';
+        const obj = data;
+        const keys = Object.keys(obj);
+        const previews = [];
+        for (const key of keys) {
+            const value = obj[key];
+            if (Array.isArray(value)) {
+                previews.push(`${colors.blue}${key}${colors.reset}: ${colors.magenta}[${value.length} items]${colors.reset}`);
+            }
+            else if (value && typeof value === 'object') {
+                const subKeys = Object.keys(value);
+                if ('items' in value) {
+                    const items = value.items;
+                    if (Array.isArray(items)) {
+                        previews.push(`${colors.blue}${key}.items${colors.reset}: ${colors.magenta}[${items.length} items]${colors.reset}`);
+                    }
+                }
+                else {
+                    previews.push(`${colors.blue}${key}${colors.reset}: ${colors.dim}{${subKeys.slice(0, 3).join(', ')}${subKeys.length > 3 ? '...' : ''}}${colors.reset}`);
+                }
+            }
+            else if (value !== null && value !== undefined) {
+                const strVal = String(value);
+                previews.push(`${colors.blue}${key}${colors.reset}: ${colors.green}${truncate(strVal, 30)}${colors.reset}`);
+            }
+        }
+        return previews.join(', ');
+    }
+    /**
+     * Log general info
+     */
+    info(message, data) {
+        if (!isEnabled())
+            return;
+        this.log('info', message);
+        if (data) {
+            console.log(`  ${colors.dim}${formatJson(data, 200)}${colors.reset}`);
+        }
+    }
+    /**
+     * Log a warning
+     */
+    warn(message, data) {
+        if (!isEnabled())
+            return;
+        this.log('warn', `${colors.yellow}${message}${colors.reset}`);
+        if (data) {
+            console.log(`  ${colors.dim}${formatJson(data, 200)}${colors.reset}`);
+        }
+    }
+    /**
+     * Get request statistics
+     */
+    getStats() {
+        return {
+            totalRequests: this.requestCount,
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.requestCount = 0;
+    }
+}
+// Export singleton instance
+export const logger = new MagentoLogger();
+// Export class for custom instances
+export { MagentoLogger };

package/dist/magento-types.d.ts

@@ -0,0 +1,357 @@
+/**
+ * Raw Magento GraphQL response shapes (the fields our queries request and our
+ * mappers read). These are intentionally partial — only what we consume — so a
+ * backend schema change to a field we use surfaces as a build error instead of
+ * a silent `undefined` at runtime.
+ *
+ * Note: Magento exposes numeric ids as `Int` (e.g. product/category `id`, order
+ * `id`), so id-ish fields are typed `string | number`; mappers coerce to string
+ * where the shared types require it.
+ */
+export interface MagentoMoney {
+    value: number;
+    currency: string;
+}
+/** A `user_errors` entry returned by Magento cart/wishlist mutations. */
+export interface MagentoUserError {
+    code?: string;
+    message: string;
+}
+export type MagentoPrice = MagentoMoney;
+export interface MagentoProductPrice {
+    regular_price: MagentoPrice;
+    final_price: MagentoPrice;
+    discount?: {
+        amount_off: number;
+        percent_off: number;
+    };
+}
+export interface MagentoTierPrice {
+    quantity: number;
+    final_price: MagentoPrice;
+    discount?: {
+        amount_off: number;
+        percent_off: number;
+    };
+}
+export interface MagentoAttributeItemV2 {
+    code: string;
+    __typename?: string;
+    value?: string | null;
+    selected_options?: Array<{
+        label: string;
+        value: string;
+    }> | null;
+}
+export interface MagentoCustomAttributesV2 {
+    items?: MagentoAttributeItemV2[] | null;
+    errors?: Array<{
+        message: string;
+    }> | null;
+}
+export interface MagentoProduct {
+    __typename?: string;
+    id?: string;
+    uid?: string;
+    sku: string;
+    name: string;
+    url_key: string;
+    description?: {
+        html: string;
+    };
+    short_description?: {
+        html: string;
+    };
+    meta_title?: string;
+    meta_description?: string;
+    stock_status: string;
+    price_range: {
+        minimum_price: MagentoProductPrice;
+    };
+    price_tiers?: MagentoTierPrice[] | null;
+    media_gallery?: Array<{
+        url: string;
+        label?: string;
+        position?: number;
+    }>;
+    thumbnail?: {
+        url: string;
+        label?: string;
+    };
+    categories?: Array<{
+        id: string;
+        name: string;
+        url_key: string;
+    }>;
+    custom_attributesV2?: MagentoCustomAttributesV2;
+    configurable_options?: Array<{
+        id: string;
+        attribute_code: string;
+        label: string;
+        values: Array<{
+            uid: string;
+            label: string;
+            swatch_data?: {
+                __typename?: string;
+                value: string;
+            };
+        }>;
+    }>;
+    variants?: Array<{
+        product: {
+            id: string;
+            sku: string;
+            name: string;
+            stock_status: string;
+            price_range: {
+                minimum_price: MagentoProductPrice;
+            };
+        };
+        attributes: Array<{
+            code: string;
+            label: string;
+            value_index: number;
+        }>;
+    }>;
+    items?: Array<{
+        qty: number;
+        position: number;
+        product: MagentoProduct | null;
+    }>;
+}
+export interface MagentoPageInfo {
+    current_page: number;
+    page_size: number;
+    total_pages: number;
+}
+export interface MagentoAggregation {
+    attribute_code: string;
+    label: string;
+    options?: Array<{
+        value: string;
+        label: string;
+        count: number;
+    }> | null;
+}
+export interface MagentoSortFields {
+    options?: Array<{
+        value: string;
+        label: string;
+    }> | null;
+}
+export interface MagentoCartItem {
+    uid: string;
+    quantity: number;
+    product: {
+        id: string;
+        sku: string;
+        name: string;
+        url_key?: string;
+        thumbnail?: {
+            url: string;
+            label?: string;
+        } | null;
+    };
+    prices: {
+        price: MagentoMoney;
+        row_total: {
+            value: number;
+        };
+        row_total_including_tax?: {
+            value: number;
+        } | null;
+    };
+    configurable_options?: Array<{
+        option_label: string;
+        value_label: string;
+    }> | null;
+}
+export interface MagentoCartPrices {
+    subtotal_excluding_tax?: MagentoMoney | null;
+    subtotal_including_tax?: MagentoMoney | null;
+    grand_total?: MagentoMoney | null;
+    discounts?: Array<{
+        amount: MagentoMoney;
+        label: string;
+    }> | null;
+    applied_taxes?: Array<{
+        amount: MagentoMoney;
+        label: string;
+    }> | null;
+}
+export interface MagentoShippingMethod {
+    carrier_code: string;
+    carrier_title: string;
+    method_code: string;
+    method_title: string;
+    amount?: MagentoMoney | null;
+}
+export interface MagentoPaymentMethod {
+    code: string;
+    title: string;
+}
+export interface MagentoShippingAddress {
+    firstname: string;
+    lastname: string;
+    street: string[];
+    city: string;
+    region?: {
+        label?: string;
+        code?: string;
+    } | null;
+    postcode: string;
+    country?: {
+        label?: string;
+        code?: string;
+    } | null;
+    country_code?: string;
+    telephone?: string;
+    company?: string;
+    selected_shipping_method?: MagentoShippingMethod | null;
+    available_shipping_methods?: MagentoShippingMethod[] | null;
+}
+export interface MagentoCart {
+    id: string;
+    email?: string | null;
+    items?: Array<MagentoCartItem | null> | null;
+    prices?: MagentoCartPrices | null;
+    applied_coupons?: Array<{
+        code: string;
+    }> | null;
+    shipping_addresses?: MagentoShippingAddress[] | null;
+    billing_address?: MagentoShippingAddress | null;
+    selected_payment_method?: {
+        code: string;
+        title: string;
+    } | null;
+    available_payment_methods?: MagentoPaymentMethod[] | null;
+}
+export interface MagentoCountry {
+    two_letter_abbreviation?: string | null;
+    full_name_locale?: string | null;
+    available_regions?: Array<{
+        id: number;
+        code: string;
+        name: string;
+    }> | null;
+}
+export interface MagentoCategoryBreadcrumb {
+    category_level?: number;
+    category_url_key?: string;
+    category_uid?: string;
+    category_id?: string | number;
+    category_name?: string;
+}
+export interface MagentoCategory {
+    id?: string | number;
+    uid?: string;
+    name: string;
+    url_key: string;
+    url_path?: string;
+    description?: string;
+    image?: string;
+    product_count?: number;
+    include_in_menu?: boolean | number;
+    position?: number;
+    children?: MagentoCategory[] | null;
+    breadcrumbs?: MagentoCategoryBreadcrumb[] | null;
+    meta_title?: string;
+    meta_description?: string;
+}
+export interface MagentoCmsPage {
+    identifier: string;
+    title: string;
+    content: string;
+    content_heading?: string;
+    url_key?: string;
+    meta_title?: string;
+    meta_description?: string;
+}
+export interface MagentoCmsBlock {
+    identifier: string;
+    title?: string;
+    content?: string;
+}
+export interface MagentoRoute {
+    __typename?: string;
+    type?: string;
+    id?: string | number;
+    identifier?: string;
+    uid?: string;
+    sku?: string;
+    url_key?: string;
+}
+export interface MagentoCustomerAddress {
+    id?: string | number;
+    firstname: string;
+    lastname: string;
+    street: string[];
+    city: string;
+    region?: {
+        region?: string;
+        region_code?: string;
+        region_id?: number;
+    } | null;
+    postcode: string;
+    country_code?: string;
+    telephone?: string;
+    company?: string;
+    default_shipping?: boolean;
+    default_billing?: boolean;
+}
+export interface MagentoCustomer {
+    id?: string | number;
+    email: string;
+    firstname: string;
+    lastname: string;
+    date_of_birth?: string;
+    gender?: number;
+    created_at?: string;
+    addresses?: MagentoCustomerAddress[] | null;
+}
+export interface MagentoCustomerOrderItem {
+    id?: string | number;
+    product_name: string;
+    product_sku: string;
+    quantity_ordered: number;
+    product_sale_price?: MagentoMoney | null;
+}
+export interface MagentoCustomerOrder {
+    id?: string | number;
+    number: string;
+    order_date: string;
+    status: string;
+    total?: {
+        grand_total?: MagentoMoney | null;
+        subtotal_excl_tax?: MagentoMoney | null;
+        total_shipping?: MagentoMoney | null;
+        total_tax?: MagentoMoney | null;
+        discounts?: Array<{
+            amount?: MagentoMoney | null;
+            label?: string;
+        } | null> | null;
+    } | null;
+    items?: Array<MagentoCustomerOrderItem | null> | null;
+    shipping_address?: {
+        firstname?: string;
+        lastname?: string;
+        street?: string[];
+        city?: string;
+        region?: string;
+        postcode?: string;
+        country_code?: string;
+        telephone?: string;
+    } | null;
+}
+export interface MagentoWishlistItem {
+    id: string | number;
+    added_at?: string;
+    product: MagentoProduct;
+}
+export interface MagentoWishlist {
+    id: string | number;
+    items_v2?: {
+        items?: Array<MagentoWishlistItem | null> | null;
+    } | null;
+    items_count?: number;
+}

package/dist/magento-types.js

@@ -0,0 +1,11 @@
+/**
+ * Raw Magento GraphQL response shapes (the fields our queries request and our
+ * mappers read). These are intentionally partial — only what we consume — so a
+ * backend schema change to a field we use surfaces as a build error instead of
+ * a silent `undefined` at runtime.
+ *
+ * Note: Magento exposes numeric ids as `Int` (e.g. product/category `id`, order
+ * `id`), so id-ish fields are typed `string | number`; mappers coerce to string
+ * where the shared types require it.
+ */
+export {};

package/dist/mappers.d.ts

@@ -0,0 +1,50 @@
+import type { AnyProduct, GroupedProductItem, ProductListItem, Price, ProductImage, StockStatus, ConfigurableOption, ProductVariant, CategoryReference, Cart, CartItem, CartTotals, ShippingAddress, ShippingMethod, PaymentMethod, Category, Country, NavigationItem, UrlResolverResult, CmsPage, CmsBlock, Customer, CustomerAddress } from '@cobrastyle/shared-types';
+import type { MagentoProductPrice, MagentoTierPrice, MagentoCustomAttributesV2, MagentoProduct, MagentoCart, MagentoCartItem, MagentoCartPrices, MagentoShippingAddress, MagentoShippingMethod, MagentoPaymentMethod, MagentoCountry, MagentoCategory, MagentoCmsPage, MagentoCmsBlock, MagentoRoute, MagentoCustomer, MagentoCustomerAddress, MagentoCustomerOrder, MagentoCustomerOrderItem, MagentoWishlist, MagentoWishlistItem } from './magento-types';
+export declare const mapPrice: (priceData: MagentoProductPrice, tiers?: MagentoTierPrice[] | null) => Price;
+export declare const mapImages: (mediaGallery: Array<{
+    url: string;
+    label?: string;
+    position?: number;
+}> | undefined) => ProductImage[];
+export declare const mapStock: (stockStatus: string) => StockStatus;
+export declare const mapCategories: (categories: Array<{
+    id: string;
+    name: string;
+    url_key: string;
+    breadcrumbs?: Array<{
+        category_url_key: string;
+        category_level?: number;
+    }> | null;
+}> | undefined, categorySuffix?: string) => CategoryReference[];
+export declare const mapConfigurableOptions: (options: MagentoProduct["configurable_options"]) => ConfigurableOption[];
+export declare const mapVariants: (variants: MagentoProduct["variants"]) => ProductVariant[];
+export declare const mapCustomAttributes: (custom: MagentoCustomAttributesV2 | undefined, labelMap?: ReadonlyMap<string, string>) => Array<{
+    code: string;
+    label: string;
+    value: string;
+}>;
+export declare const mapGroupedItems: (items: NonNullable<MagentoProduct["items"]>, productSuffix?: string) => GroupedProductItem[];
+export declare const mapProduct: (product: MagentoProduct, productSuffix?: string, categorySuffix?: string, attributeLabels?: ReadonlyMap<string, string>) => AnyProduct;
+export declare const mapProductListItem: (product: MagentoProduct, productSuffix?: string) => ProductListItem;
+export declare const mapCart: (magentoCart: MagentoCart, productSuffix?: string) => Cart;
+export declare const mapCartItems: (items: Array<MagentoCartItem | null>, productSuffix?: string) => CartItem[];
+export declare const mapCartTotals: (prices: MagentoCartPrices) => CartTotals;
+export declare const mapShippingAddress: (addr: MagentoShippingAddress) => ShippingAddress;
+export declare const mapShippingMethod: (method: MagentoShippingMethod) => ShippingMethod;
+export declare const mapPaymentMethod: (method: MagentoPaymentMethod) => PaymentMethod;
+export declare const mapCountry: (country: MagentoCountry) => Country;
+export declare const mapCountries: (countries: MagentoCountry[]) => Country[];
+export declare const mapCategory: (cat: MagentoCategory, suffix?: string, ancestorSegments?: string[]) => Category;
+export declare const isIncludedInMenu: (cat: {
+    include_in_menu?: boolean | number;
+}) => boolean;
+export declare const mapNavigationItem: (cat: MagentoCategory, level?: number, parentSegments?: string[], suffix?: string) => NavigationItem;
+export declare const mapCmsPage: (page: MagentoCmsPage) => CmsPage;
+export declare const mapCmsBlock: (block: MagentoCmsBlock) => CmsBlock;
+export declare const mapUrlResolver: (route: MagentoRoute | null | undefined) => UrlResolverResult;
+export declare const mapCustomer: (customer: MagentoCustomer) => Customer;
+export declare const mapCustomerAddress: (addr: MagentoCustomerAddress) => CustomerAddress;
+export declare const mapCustomerOrder: (order: MagentoCustomerOrder) => import("@cobrastyle/shared-types").CustomerOrder;
+export declare const mapCustomerOrderItem: (item: MagentoCustomerOrderItem) => import("@cobrastyle/shared-types").CustomerOrderItem;
+export declare const mapWishlistItem: (item: MagentoWishlistItem) => import("@cobrastyle/shared-types").WishlistItem;
+export declare const mapWishlist: (wishlist: MagentoWishlist) => import("@cobrastyle/shared-types").Wishlist;