@simpleapps-com/augur-api 0.1.0

package/dist/cjs/services/commerce/client.d.ts

@@ -0,0 +1,510 @@
+import { BaseServiceClient } from '../../core/base-client';
+import type { HTTPClient } from '../../core/client';
+import { CartHdrLookupParams, CartHdrLookupResponse, CartLineAddRequest, CartLineUpdateRequest, CartLineModifyResponse, AlsoBoughtParams, AlsoBoughtResponse, CheckoutDocParams } from './schemas';
+/**
+ * Commerce API Client
+ * @description Client for interacting with Commerce microservice API endpoints for e-commerce operations
+ * @example
+ * ```typescript
+ * import { HTTPClient } from '@augur/api-client/core';
+ * import { CommerceClient } from '@augur/api-client/services/commerce';
+ *
+ * const http = new HTTPClient('commerce', { siteId: 'your-site-id', bearerToken: 'your-token' });
+ * const commerce = new CommerceClient(http);
+ *
+ * // Create or lookup cart
+ * const cart = await commerce.cartHeaders.lookup({ userId: 12345, customerId: 456, contactId: 123 });
+ *
+ * // Add items to cart
+ * await commerce.cartLines.add(cart.cartHdrUid, [{ invMastUid: 12345, quantity: 2, unitOfMeasure: 'EA' }]);
+ *
+ * // Create checkout
+ * const checkout = await commerce.checkout.create({ customer: {...}, payment: {...}, lineItems: [...] });
+ * ```
+ */
+export declare class CommerceClient extends BaseServiceClient {
+    /**
+     * Create a new CommerceClient instance
+     * @param http Configured HTTPClient instance
+     * @param baseUrl Base URL for the Commerce API (default: https://commerce.augur-api.com)
+     */
+    constructor(http: HTTPClient, baseUrl?: string);
+    /**
+     * Cart Header endpoints
+     * @description Methods for shopping cart session management with user tracking and cart tokens
+     */
+    cartHeaders: {
+        /**
+         * Retrieve a list of cart headers for a specific user
+         * @description Returns all cart headers associated with a user ID
+         * @param params User ID for filtering cart headers
+         * @returns Array of cart headers for the user
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const carts = await client.cartHeaders.list({ userId: 12345 });
+         * carts.forEach(cart => console.log(cart.cartHdrUid, cart.cartToken));
+         * ```
+         */
+        list: (params?: {
+            userId: number;
+            edgeCache?: 3 | 2 | 4 | 1 | 5 | 8 | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+        } | undefined) => Promise<{
+            data: {
+                customerId: number;
+                contactId: number;
+                userId: number;
+                cartHdrUid: number;
+                dateCreated?: string | undefined;
+                dateLastModified?: string | undefined;
+                statusCd?: number | undefined;
+                sessionId?: string | undefined;
+                emailAddress?: string | undefined;
+                cartToken?: string | undefined;
+                userCartNo?: number | undefined;
+                version?: number | undefined;
+                processCd?: number | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Lookup an existing cart or create a new one
+         * @description Looks up an existing cart or creates a new one for the specified user, customer, and contact
+         * @param params User, customer, and contact identifiers with optional cart token
+         * @returns Cart header details with cart token and user cart number
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * // Lookup existing cart
+         * const cart = await client.cartHeaders.lookup({
+         *   userId: 12345,
+         *   customerId: 456,
+         *   contactId: 123,
+         *   cartToken: 'abc123'
+         * });
+         *
+         * // Create new cart
+         * const newCart = await client.cartHeaders.lookup({
+         *   userId: 12345,
+         *   customerId: 456,
+         *   contactId: 123
+         * });
+         * ```
+         */
+        lookup: (params: CartHdrLookupParams) => Promise<CartHdrLookupResponse>;
+        /**
+         * Get product recommendations based on cart contents
+         * @description Retrieves also-bought product recommendations based on items currently in the cart
+         * @param cartHdrUid Cart header unique identifier
+         * @param params Optional pagination parameters
+         * @returns Paginated list of recommended products with count and total
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const recommendations = await client.cartHeaders.getAlsoBought(789, { limit: 5, offset: 0 });
+         * console.log(`Found ${recommendations.total} recommendations, showing ${recommendations.count}`);
+         * recommendations.data.forEach(item => console.log(item.itemId, item.description, item.price));
+         * ```
+         */
+        getAlsoBought: (cartHdrUid: number, params?: AlsoBoughtParams) => Promise<AlsoBoughtResponse>;
+    };
+    /**
+     * Cart Line endpoints
+     * @description Methods for managing individual line items within shopping carts
+     */
+    cartLines: {
+        /**
+         * Retrieve all line items for a specific cart
+         * @description Returns all line items in a cart with product details, quantities, and pricing
+         * @param cartHdrUid Cart header unique identifier
+         * @returns Array of cart line items with product and pricing information
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const lines = await client.cartLines.get(789);
+         * lines.forEach(line => {
+         *   console.log(`Line ${line.lineNo}: ${line.quantity} x ${line.itemId} @ $${line.unitPrice}`);
+         * });
+         * ```
+         */
+        get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            data: {
+                lineNo: number;
+                invMastUid: number;
+                key?: string | undefined;
+                dateCreated?: string | undefined;
+                dateLastModified?: string | undefined;
+                cartHdrUid?: number | undefined;
+                quantity?: number | undefined;
+                unitOfMeasure?: string | undefined;
+                lineNote?: string | undefined;
+                unitPrice?: number | undefined;
+                itemId?: string | undefined;
+                isAssembly?: string | undefined;
+                invMastUidCount?: number | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Add one or more items to the cart
+         * @description Adds line items to the shopping cart with automatic quantity aggregation for matching items
+         * @param cartHdrUid Cart header unique identifier
+         * @param items Array of cart line items to add
+         * @returns Boolean indicating successful addition
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const success = await client.cartLines.add(789, [
+         *   {
+         *     invMastUid: 12345,
+         *     quantity: 2.0,
+         *     unitOfMeasure: 'EA',
+         *     lineNote: 'Rush order',
+         *     unitPrice: 29.99
+         *   },
+         *   {
+         *     invMastUid: 67890,
+         *     quantity: 1.0,
+         *     unitOfMeasure: 'LB'
+         *   }
+         * ]);
+         * ```
+         */
+        add: (cartHdrUid: number, items: CartLineAddRequest) => Promise<CartLineModifyResponse>;
+        /**
+         * Update quantities or details for existing cart line items
+         * @description Updates existing line items in the cart with new quantities, notes, or other modifications
+         * @param cartHdrUid Cart header unique identifier
+         * @param items Array of cart line items to update (must specify lineNo or key for identification)
+         * @returns Boolean indicating successful update
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const success = await client.cartLines.update(789, [
+         *   {
+         *     lineNo: 1,
+         *     quantity: 5.0,
+         *     lineNote: 'Updated quantity to 5'
+         *   },
+         *   {
+         *     key: 'unique-key-123',
+         *     quantity: 3.0
+         *   }
+         * ]);
+         * ```
+         */
+        update: (cartHdrUid: number, items: CartLineUpdateRequest) => Promise<CartLineModifyResponse>;
+        /**
+         * Remove all line items from the cart
+         * @description Clears all line items from the specified cart, leaving the cart header intact
+         * @param cartHdrUid Cart header unique identifier
+         * @returns Boolean indicating successful clearing of cart
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const success = await client.cartLines.clear(789);
+         * if (success) {
+         *   console.log('Cart has been cleared of all items');
+         * }
+         * ```
+         */
+        clear: (id: string | number) => Promise<{
+            data: boolean;
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Remove a specific line item from the cart
+         * @description Removes a single line item from the cart by line number
+         * @param cartHdrUid Cart header unique identifier
+         * @param lineNo Line number to delete
+         * @returns Boolean indicating successful deletion
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const success = await client.cartLines.deleteLine(789, 1);
+         * if (success) {
+         *   console.log('Line item 1 has been removed from cart');
+         * }
+         * ```
+         */
+        deleteLine: (cartHdrUid: number, lineNo: number) => Promise<CartLineModifyResponse>;
+    };
+    /**
+     * Checkout endpoints
+     * @description Methods for end-to-end checkout processing with Prophet21 ERP integration
+     */
+    checkout: {
+        /**
+         * Create a new checkout session
+         * @description Creates a new checkout with complete order data including customer, payment, and line items
+         * @param orderData Complete checkout data with customer information, payment details, and line items
+         * @returns Created checkout with unique identifiers and status
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const checkout = await client.checkout.create({
+         *   customer: {
+         *     customerId: 456,
+         *     contactId: 123,
+         *     billToName: 'John Doe',
+         *     billToAddress1: '123 Main St',
+         *     billToCity: 'Anytown',
+         *     billToState: 'CA',
+         *     billToZip: '12345',
+         *     billToCountry: 'US',
+         *     shipToName: 'John Doe',
+         *     shipToAddress1: '123 Main St',
+         *     shipToCity: 'Anytown',
+         *     shipToState: 'CA',
+         *     shipToZip: '12345',
+         *     shipToCountry: 'US'
+         *   },
+         *   payment: {
+         *     paymentType: 'CC',
+         *     cardNumber: '4111111111111111',
+         *     expirationDate: '12/25',
+         *     cvv: '123',
+         *     cardHolderName: 'John Doe'
+         *   },
+         *   lineItems: [
+         *     { invMastUid: 12345, quantity: 2, unitOfMeasure: 'EA', unitPrice: 29.99 }
+         *   ]
+         * });
+         * ```
+         */
+        create: (data: {
+            customer: {
+                customerId: number;
+                contactId: number;
+                billToName: string;
+                billToAddress1: string;
+                billToCity: string;
+                billToState: string;
+                billToZip: string;
+                billToCountry: string;
+                shipToName: string;
+                shipToAddress1: string;
+                shipToCity: string;
+                shipToState: string;
+                shipToZip: string;
+                shipToCountry: string;
+            };
+            payment: {
+                paymentType: string;
+                cardNumber: string;
+                expirationDate: string;
+                cvv: string;
+                cardHolderName: string;
+            };
+            lineItems: {
+                invMastUid: number;
+                quantity: number;
+                unitOfMeasure: string;
+                unitPrice: number;
+            }[];
+            shipping?: {
+                shippingMethod: string;
+                shippingInstructions?: string | undefined;
+            } | undefined;
+        }) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                statusCd: number;
+                cartHdrUid: number;
+                checkoutUid: number;
+                checkoutUuid: string;
+                body?: unknown;
+                checkoutType?: string | undefined;
+                properties?: string | undefined;
+                checkoutProcessor?: string | undefined;
+                jsonData?: string | undefined;
+                sourceName?: string | undefined;
+                sourceId?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Get checkout details by ID
+         * @description Retrieves complete details for a specific checkout including all order data
+         * @param checkoutUid Checkout unique identifier
+         * @returns Complete checkout details with order data and processing status
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const checkout = await client.checkout.get(12345);
+         * console.log('Checkout:', checkout.checkoutUid, 'Status:', checkout.statusCd);
+         * console.log('Created:', checkout.dateCreated, 'Type:', checkout.checkoutType);
+         * ```
+         */
+        get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            data: {
+                dateCreated: string;
+                dateLastModified: string;
+                statusCd: number;
+                cartHdrUid: number;
+                checkoutUid: number;
+                checkoutUuid: string;
+                body?: unknown;
+                checkoutType?: string | undefined;
+                properties?: string | undefined;
+                checkoutProcessor?: string | undefined;
+                jsonData?: string | undefined;
+                sourceName?: string | undefined;
+                sourceId?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Get formatted checkout document
+         * @description Retrieves the formatted checkout document/receipt for display or printing
+         * @param checkoutUid Checkout unique identifier
+         * @param params Optional parameters including associated cart header UID
+         * @returns Raw checkout document response
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const doc = await client.checkout.getDoc(12345, { cartHdrUid: 789 });
+         * // Process or display the formatted document
+         * ```
+         */
+        getDoc: (checkoutUid: number, params?: CheckoutDocParams) => Promise<unknown>;
+        /**
+         * Validate checkout data
+         * @description Validates checkout data without processing payment or creating orders in Prophet21
+         * @param checkoutUid Checkout unique identifier
+         * @returns Validation results with status, errors, and warnings
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const validation = await client.checkout.validate(12345);
+         * if (validation.data.validationResults?.isValid) {
+         *   console.log('Checkout is valid and ready for activation');
+         * } else {
+         *   console.log('Validation errors:', validation.data.validationResults?.errors);
+         * }
+         * ```
+         */
+        validate: (id: string | number) => Promise<{
+            data: {
+                statusCd: number;
+                checkoutUid: number;
+                checkoutUuid: string;
+                validationResults?: {
+                    errors: string[];
+                    isValid: boolean;
+                    warnings: string[];
+                } | undefined;
+            };
+            status: number;
+            message: string;
+        }>;
+        /**
+         * Activate and process checkout
+         * @description Activates the checkout, processes payment, and creates orders in Prophet21 ERP system
+         * @param checkoutUid Checkout unique identifier
+         * @returns Activated checkout details with updated status
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const result = await client.checkout.activate(12345);
+         * if (result.data.statusCd === 710) {
+         *   console.log('Checkout successfully activated and processed');
+         * }
+         * ```
+         */
+        activate: (id: string | number) => Promise<{
+            data: {
+                statusCd: number;
+                checkoutUid: number;
+                checkoutUuid: string;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Create Prophet21 checkout header
+         * @description Creates Prophet21-specific checkout header for ERP integration (partially implemented)
+         * @param checkoutUid Checkout unique identifier
+         * @returns Prophet21 header creation result
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const p21Header = await client.checkout.createProphet21Hdr(12345);
+         * // Note: This endpoint is partially implemented
+         * ```
+         */
+        createProphet21Hdr: (id: string | number) => Promise<{
+            status: number;
+            data?: unknown;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Add Prophet21 checkout lines
+         * @description Adds line items to Prophet21 checkout header (in early development)
+         * @param checkoutUid Checkout unique identifier
+         * @param prophet21HdrUid Prophet21 header unique identifier
+         * @returns Prophet21 line creation result
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const p21Lines = await client.checkout.addProphet21Lines(12345, 67890);
+         * // Note: This endpoint is in early development
+         * ```
+         */
+        addProphet21Lines: (checkoutUid: number, prophet21HdrUid: number) => Promise<unknown>;
+    };
+    /**
+     * Check service health (no bearer token required)
+     * @description Monitor service availability and site configuration without authentication overhead
+     * @returns Health check response with site hash and ID for configuration verification
+     * @throws ValidationError When response is malformed
+     * @example
+     * ```typescript
+     * const health = await client.getHealthCheck();
+     * console.log('Service health:', health.status);
+     * console.log('Site ID:', health.data.siteId);
+     * console.log('Site Hash:', health.data.siteHash);
+     * ```
+     */
+    getHealthCheck: () => Promise<{
+        data: {
+            siteHash: string;
+            siteId: string;
+        };
+        status: number;
+        options?: Record<string, unknown>[] | undefined;
+        message?: string | undefined;
+        totalResults?: number | undefined;
+        count?: number | undefined;
+    }>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/cjs/services/commerce/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/commerce/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAGL,mBAAmB,EAEnB,qBAAqB,EAErB,kBAAkB,EAElB,qBAAqB,EAGrB,sBAAsB,EAEtB,gBAAgB,EAEhB,kBAAkB,EAKlB,iBAAiB,EAOlB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,cAAe,SAAQ,iBAAiB;IACnD;;;;OAIG;gBACS,IAAI,EAAE,UAAU,EAAE,OAAO,GAAE,MAAyC;IAIhF;;;OAGG;IACH,WAAW;QACT;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAOH;;;;;;;;;;;;;;;;;;;;;;;WAuBG;yBACoB,mBAAmB,KAAG,OAAO,CAAC,qBAAqB,CAAC;QAY3E;;;;;;;;;;;;;WAaG;oCAEW,MAAM,WACT,gBAAgB,KACxB,OAAO,CAAC,kBAAkB,CAAC;MAY9B;IAEF;;;OAGG;IACH,SAAS;QACP;;;;;;;;;;;;;WAaG;;;;;;;;;;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;WAwBG;0BACqB,MAAM,SAAS,kBAAkB,KAAG,OAAO,CAAC,sBAAsB,CAAC;QAa3F;;;;;;;;;;;;;;;;;;;;;WAqBG;6BAEW,MAAM,SACX,qBAAqB,KAC3B,OAAO,CAAC,sBAAsB,CAAC;QAalC;;;;;;;;;;;;;WAaG;;;;;;;;;QAGH;;;;;;;;;;;;;;WAcG;iCAC4B,MAAM,UAAU,MAAM,KAAG,OAAO,CAAC,sBAAsB,CAAC;MAWvF;IAEF;;;OAGG;IACH,QAAQ;QACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAqCG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAOH;;;;;;;;;;;;WAYG;;;;;;;;;;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;WAYG;8BACyB,MAAM,WAAW,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC;QASjF;;;;;;;;;;;;;;;WAeG;;;;;;;;;;;;;;;QAOH;;;;;;;;;;;;;WAaG;;;;;;;;;;;;;QAOH;;;;;;;;;;;WAWG;;;;;;;;;QAOH;;;;;;;;;;;;WAYG;yCACoC,MAAM,mBAAmB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;MAWzF;IAEF;;;;;;;;;;;;OAYG;IACH,cAAc;;;;;;;;;;OAA2D;CAC1E"}