@commercengine/storefront-sdk 0.1.0

package/dist/lib/cart.d.ts

@@ -0,0 +1,114 @@
+import { StorefrontAPIClient } from "./client";
+import type { components } from "../types/storefront";
+/**
+ * Client for interacting with cart endpoints
+ */
+export declare class CartClient extends StorefrontAPIClient {
+    /**
+     * Create a new cart
+     *
+     * @param payload - Object containing the items to add to the cart
+     * @returns Promise with the created cart
+     */
+    createCart(payload: {
+        items: components["schemas"]["UpdateCartItem"][];
+    }): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Get cart details by ID
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with cart details
+     */
+    getCart(cartId: string): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Delete a cart by ID
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise that resolves when the cart is deleted
+     */
+    deleteCart(cartId: string): Promise<void>;
+    /**
+     * Get cart details by user ID
+     *
+     * @param userId - The ID of the user
+     * @returns Promise with cart details
+     */
+    getUserCart(userId: string): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Delete a cart by user ID
+     *
+     * @param userId - The ID of the user
+     * @returns Promise that resolves when the cart is deleted
+     */
+    deleteUserCart(userId: string): Promise<void>;
+    /**
+     * Update cart items (add, update quantity, remove)
+     *
+     * @param cartId - The ID of the cart
+     * @param item - The item data
+     * @returns Promise with updated cart
+     */
+    updateCartItem(cartId: string, item: components["schemas"]["UpdateCartItem"]): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Update cart addresses
+     *
+     * @param cartId - The ID of the cart
+     * @param addressData - The address data
+     * @returns Promise with updated cart
+     */
+    updateCartAddress(cartId: string, addressData: {
+        billing_address_id: string;
+        shipping_address_id: string;
+    } | {
+        billing_address: components["schemas"]["CustomerAddress"];
+        shipping_address: components["schemas"]["CustomerAddress"];
+    }): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Apply a coupon to the cart
+     *
+     * @param cartId - The ID of the cart
+     * @param couponCode - The coupon code
+     * @returns Promise with updated cart
+     */
+    applyCoupon(cartId: string, couponCode: string): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Remove a coupon from the cart
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with updated cart
+     */
+    removeCoupon(cartId: string): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Redeem loyalty points
+     *
+     * @param cartId - The ID of the cart
+     * @param points - The number of points to redeem
+     * @returns Promise with updated cart
+     */
+    redeemLoyaltyPoints(cartId: string, points: number): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Remove loyalty points
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with updated cart
+     */
+    removeLoyaltyPoints(cartId: string): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+}

package/dist/lib/cart.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartClient = void 0;
+const client_1 = require("./client");
+/**
+ * Client for interacting with cart endpoints
+ */
+class CartClient extends client_1.StorefrontAPIClient {
+    /**
+     * Create a new cart
+     *
+     * @param payload - Object containing the items to add to the cart
+     * @returns Promise with the created cart
+     */
+    async createCart(payload) {
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.POST("/carts", {
+                body: payload,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Get cart details by ID
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with cart details
+     */
+    async getCart(cartId) {
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/carts/{id}", {
+                params: {
+                    path: { id: cartId },
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Delete a cart by ID
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise that resolves when the cart is deleted
+     */
+    async deleteCart(cartId) {
+        const { error } = await this.client.DELETE("/carts/{id}", {
+            params: {
+                path: { id: cartId },
+            },
+            body: undefined,
+        });
+        if (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Get cart details by user ID
+     *
+     * @param userId - The ID of the user
+     * @returns Promise with cart details
+     */
+    async getUserCart(userId) {
+        const { data, error } = await this.client.GET("/carts/users/{user_id}", {
+            params: {
+                path: { user_id: userId },
+            },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Delete a cart by user ID
+     *
+     * @param userId - The ID of the user
+     * @returns Promise that resolves when the cart is deleted
+     */
+    async deleteUserCart(userId) {
+        const { error } = await this.client.DELETE("/carts/users/{user_id}", {
+            params: {
+                path: { user_id: userId },
+            },
+            body: undefined,
+        });
+        if (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Update cart items (add, update quantity, remove)
+     *
+     * @param cartId - The ID of the cart
+     * @param item - The item data
+     * @returns Promise with updated cart
+     */
+    async updateCartItem(cartId, item) {
+        const { data, error } = await this.client.POST("/carts/{id}/items", {
+            params: {
+                path: { id: cartId },
+            },
+            body: item,
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Update cart addresses
+     *
+     * @param cartId - The ID of the cart
+     * @param addressData - The address data
+     * @returns Promise with updated cart
+     */
+    async updateCartAddress(cartId, addressData) {
+        const { data, error } = await this.client.POST("/carts/{id}/address", {
+            params: {
+                path: { id: cartId },
+            },
+            body: addressData,
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Apply a coupon to the cart
+     *
+     * @param cartId - The ID of the cart
+     * @param couponCode - The coupon code
+     * @returns Promise with updated cart
+     */
+    async applyCoupon(cartId, couponCode) {
+        const { data, error } = await this.client.POST("/carts/{id}/coupon", {
+            params: {
+                path: { id: cartId },
+            },
+            body: { coupon_code: couponCode },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Remove a coupon from the cart
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with updated cart
+     */
+    async removeCoupon(cartId) {
+        const { data, error } = await this.client.DELETE("/carts/{id}/coupon", {
+            params: {
+                path: { id: cartId },
+            },
+            body: undefined,
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Redeem loyalty points
+     *
+     * @param cartId - The ID of the cart
+     * @param points - The number of points to redeem
+     * @returns Promise with updated cart
+     */
+    async redeemLoyaltyPoints(cartId, points) {
+        const { data, error } = await this.client.POST("/carts/{id}/loyalty-points", {
+            params: {
+                path: { id: cartId },
+            },
+            body: { loyalty_point_redeemed: points },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Remove loyalty points
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with updated cart
+     */
+    async removeLoyaltyPoints(cartId) {
+        const { data, error } = await this.client.DELETE("/carts/{id}/loyalty-points", {
+            params: {
+                path: { id: cartId },
+            },
+            body: undefined,
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+}
+exports.CartClient = CartClient;

package/dist/lib/catalog.d.ts

@@ -0,0 +1,130 @@
+import { StorefrontAPIClient } from "./client";
+import type { components } from "../types/storefront";
+/**
+ * Client for interacting with catalog endpoints
+ */
+export declare class CatalogClient extends StorefrontAPIClient {
+    /**
+     * List all products
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with products and pagination info
+     */
+    listProducts(options?: {
+        page?: number;
+        limit?: number;
+        sort_by?: string;
+        category_id?: string[];
+        customer_group_id?: string;
+    }): Promise<{
+        products: components["schemas"]["Product"][];
+        pagination: components["schemas"]["Pagination"];
+    }>;
+    /**
+     * Get details for a specific product
+     *
+     * @param productId - The ID of the product
+     * @param options - Optional query parameters
+     * @returns Promise with product details
+     */
+    getProductDetail(productId: string, options?: {
+        customer_group_id?: string;
+    }): Promise<{
+        product: components["schemas"]["ProductDetail"];
+    }>;
+    /**
+     * List variants for a specific product
+     *
+     * @param productId - The ID of the product
+     * @param options - Optional query parameters
+     * @returns Promise with variants
+     */
+    listProductVariants(productId: string, options?: {
+        customer_group_id?: string;
+    }): Promise<{
+        variants: components["schemas"]["Variant"][];
+    }>;
+    /**
+     * Get details for a specific variant
+     *
+     * @param productId - The ID of the product
+     * @param variantId - The ID of the variant
+     * @param options - Optional query parameters
+     * @returns Promise with variant details
+     */
+    getVariantDetail(productId: string, variantId: string, options?: {
+        customer_group_id?: string;
+    }): Promise<{
+        variant: components["schemas"]["VariantDetail"];
+    }>;
+    /**
+     * List all categories
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with categories and pagination info
+     */
+    listCategories(options?: {
+        parent_category_id?: string;
+        nested_level?: number;
+        search?: string;
+        sort_by?: string;
+    }): Promise<{
+        categories: components["schemas"]["ProductCategory"][];
+        pagination: components["schemas"]["Pagination"];
+    }>;
+    /**
+     * List reviews for a specific product
+     *
+     * @param productId - The ID of the product
+     * @param options - Optional query parameters
+     * @returns Promise with reviews and pagination info
+     */
+    listProductReviews(productId: string, options?: {
+        page?: number;
+        limit?: number;
+        sort_by?: string;
+        search?: string;
+        review_tag?: string;
+    }): Promise<{
+        reviews: components["schemas"]["ProductReview"][];
+        review_tags?: string[] | null;
+        pagination?: components["schemas"]["Pagination"];
+    }>;
+    /**
+     * Create a review for a specific product
+     *
+     * @param productId - The ID of the product
+     * @param reviewData - The review data
+     * @returns Promise that resolves when the review is created
+     */
+    createProductReview(productId: string, reviewData: components["schemas"]["CreateReview"]): Promise<void>;
+    /**
+     * Search for products
+     *
+     * @param searchData - The search parameters
+     * @returns Promise with search results
+     */
+    searchProducts(searchData: components["schemas"]["SearchProduct"]): Promise<{
+        skus: components["schemas"]["SKU"][];
+        facet_distribution: {
+            [key: string]: {
+                [key: string]: number;
+            };
+        };
+        facet_stats: {
+            [key: string]: {
+                min: number;
+                max: number;
+            };
+        };
+        pagination: components["schemas"]["Pagination"];
+    }>;
+    /**
+     * Get product details by ID (alternative implementation)
+     * @param productId - The product ID to retrieve
+     * @returns Promise with the product details
+     */
+    getProduct(productId: string): Promise<{
+        product: components["schemas"]["ProductDetail"];
+    }>;
+}

package/dist/lib/catalog.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogClient = void 0;
+const client_1 = require("./client");
+/**
+ * Client for interacting with catalog endpoints
+ */
+class CatalogClient extends client_1.StorefrontAPIClient {
+    /**
+     * List all products
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with products and pagination info
+     */
+    async listProducts(options) {
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/catalog/products", {
+                params: { query: options },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Get details for a specific product
+     *
+     * @param productId - The ID of the product
+     * @param options - Optional query parameters
+     * @returns Promise with product details
+     */
+    async getProductDetail(productId, options) {
+        const { data, error } = await this.client.GET("/catalog/products/{product_id}", {
+            params: {
+                path: { product_id: productId },
+                query: options,
+            },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * List variants for a specific product
+     *
+     * @param productId - The ID of the product
+     * @param options - Optional query parameters
+     * @returns Promise with variants
+     */
+    async listProductVariants(productId, options) {
+        const { data, error } = await this.client.GET("/catalog/products/{product_id}/variants", {
+            params: {
+                path: { product_id: productId },
+                query: options,
+            },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Get details for a specific variant
+     *
+     * @param productId - The ID of the product
+     * @param variantId - The ID of the variant
+     * @param options - Optional query parameters
+     * @returns Promise with variant details
+     */
+    async getVariantDetail(productId, variantId, options) {
+        const { data, error } = await this.client.GET("/catalog/products/{product_id}/variants/{variant_id}", {
+            params: {
+                path: {
+                    product_id: productId,
+                    variant_id: variantId,
+                },
+                query: options,
+            },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * List all categories
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with categories and pagination info
+     */
+    async listCategories(options) {
+        const { data, error } = await this.client.GET("/catalog/categories", {
+            params: { query: options },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * List reviews for a specific product
+     *
+     * @param productId - The ID of the product
+     * @param options - Optional query parameters
+     * @returns Promise with reviews and pagination info
+     */
+    async listProductReviews(productId, options) {
+        const { data, error } = await this.client.GET("/catalog/products/{product_id}/reviews", {
+            params: {
+                path: { product_id: productId },
+                query: options,
+            },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Create a review for a specific product
+     *
+     * @param productId - The ID of the product
+     * @param reviewData - The review data
+     * @returns Promise that resolves when the review is created
+     */
+    async createProductReview(productId, reviewData) {
+        // Note: In a real implementation, you would need to handle multipart/form-data
+        // This would require FormData and may need additional handling
+        const { error } = await this.client.POST("/catalog/products/{product_id}/reviews", {
+            params: {
+                path: { product_id: productId },
+            },
+            body: reviewData,
+            // This is simplified as we're not properly handling multipart/form-data
+        });
+        if (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Search for products
+     *
+     * @param searchData - The search parameters
+     * @returns Promise with search results
+     */
+    async searchProducts(searchData) {
+        const { data, error } = await this.client.POST("/catalog/products/search", {
+            body: searchData,
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        return data?.content;
+    }
+    /**
+     * Get product details by ID (alternative implementation)
+     * @param productId - The product ID to retrieve
+     * @returns Promise with the product details
+     */
+    async getProduct(productId) {
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/catalog/products/{product_id}", {
+                params: {
+                    path: { product_id: productId },
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
+        });
+    }
+}
+exports.CatalogClient = CatalogClient;