@simpleapps-com/augur-server 0.2.3 → 0.2.5

package/dist/chunk-I7EWYSPA.js

@@ -0,0 +1,27 @@
+// src/server-query-client.ts
+import { cache } from "react";
+import { QueryClient } from "@tanstack/react-query";
+import { CACHE_CONFIG } from "@simpleapps-com/augur-utils";
+function createServerQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: CACHE_CONFIG.STATIC.staleTime,
+        gcTime: CACHE_CONFIG.STATIC.staleTime,
+        retry: 0,
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false
+      }
+    }
+  });
+}
+var getServerQueryClient = cache(
+  () => createServerQueryClient()
+);
+
+export {
+  createServerQueryClient,
+  getServerQueryClient
+};
+//# sourceMappingURL=chunk-I7EWYSPA.js.map

package/dist/chunk-I7EWYSPA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server-query-client.ts"],"sourcesContent":["import { cache } from \"react\";\nimport { QueryClient } from \"@tanstack/react-query\";\nimport { CACHE_CONFIG } from \"@simpleapps-com/augur-utils\";\n\n/**\n * Creates a server-side query client optimised for prefetching.\n *\n * - No persistence (server-only)\n * - Longer cache times for prefetched data\n * - No retries (fail fast on server)\n * - No refetching (server renders are one-shot)\n */\nexport function createServerQueryClient(): QueryClient {\n  return new QueryClient({\n    defaultOptions: {\n      queries: {\n        staleTime: CACHE_CONFIG.STATIC.staleTime,\n        gcTime: CACHE_CONFIG.STATIC.staleTime,\n        retry: 0,\n        refetchOnMount: false,\n        refetchOnWindowFocus: false,\n        refetchOnReconnect: false,\n      },\n    },\n  });\n}\n\n/**\n * Returns a per-request singleton QueryClient for React Server Components.\n *\n * React's `cache()` deduplicates calls within a single server request,\n * so each request gets its own QueryClient while avoiding the cross-request\n * state leakage that a module-level singleton would cause.\n */\nexport const getServerQueryClient = cache(\n  (): QueryClient => createServerQueryClient(),\n);\n"],"mappings":";AAAA,SAAS,aAAa;AACtB,SAAS,mBAAmB;AAC5B,SAAS,oBAAoB;AAUtB,SAAS,0BAAuC;AACrD,SAAO,IAAI,YAAY;AAAA,IACrB,gBAAgB;AAAA,MACd,SAAS;AAAA,QACP,WAAW,aAAa,OAAO;AAAA,QAC/B,QAAQ,aAAa,OAAO;AAAA,QAC5B,OAAO;AAAA,QACP,gBAAgB;AAAA,QAChB,sBAAsB;AAAA,QACtB,oBAAoB;AAAA,MACtB;AAAA,IACF;AAAA,EACF,CAAC;AACH;AASO,IAAM,uBAAuB;AAAA,EAClC,MAAmB,wBAAwB;AAC7C;","names":[]}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { QueryClient } from '@tanstack/react-query';
 export { QueryOptionsConfig, createQueryOptions, createSuspenseQueryOptions } from './query.js';
+import { TPriceData, TTaxItem, TTax, TCategory, TAttribute, TInvMast, TInvMastDoc, TStockData, TItemAccessory, TStock, TCartLookUp, TCartLine, TProductItem } from '@simpleapps-com/augur-utils';
 
 declare const env: "development" | "staging" | "production";
 declare const isDev: boolean;
@@ -47,4 +48,561 @@ declare function createServerQueryClient(): QueryClient;
  */
 declare const getServerQueryClient: () => QueryClient;
 
-export { cacheGet, cacheSet, createServerQueryClient, env, getCircuitState, getServerQueryClient, isDev, isProduction, isRedisConnected, isStaging, sdkCall };
+/**
+ * Server-side cache wrapper using augur-server's Redis client.
+ *
+ * Uses the same cache key format as augur-hooks' `withCache`:
+ *   `${prefix}sdk:${methodPath}:${fnv1a(stableStringify(keyArgs))}`
+ *
+ * This means server-side cached data can be read by client-side hooks
+ * (and vice versa) when using the same prefix and method path.
+ *
+ * @param prefix     Cache key prefix (e.g. "ampro:"). Empty string if none.
+ * @param redisTtl   Redis TTL in seconds. 0 or undefined = skip caching.
+ * @param methodPath Dot-separated SDK method path (e.g. "pricing.priceEngine.get").
+ * @param fn         The async function to cache.
+ * @param keyArgs    Values to hash for the cache key.
+ */
+declare function withServerCache<T>(prefix: string, redisTtl: number | undefined, methodPath: string, fn: () => Promise<T>, ...keyArgs: unknown[]): Promise<T>;
+
+/**
+ * The subset of augur-api used by pricing actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface PricingApiClient {
+    pricing: {
+        priceEngine: {
+            get: (params: Record<string, unknown>) => Promise<{
+                data: TPriceData;
+            }>;
+        };
+        taxEngine: {
+            create: (params: Record<string, unknown>) => Promise<{
+                data: TTax;
+            }>;
+        };
+    };
+}
+interface PricingActionsConfig {
+    /** Default customer ID when none is provided by the caller. */
+    defaultCustomerId?: string | number;
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 2 (hours). */
+    edgeCache?: number;
+    /** Redis TTL for price lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for tax lookups in seconds. Default: 1800 (30 min). */
+    taxRedisTtl?: number;
+}
+interface PricingActions {
+    getItemPrice: (itemId: string, customerId?: string | number, quantity?: number) => Promise<TPriceData>;
+    batchGetItemPrices: (itemIds: string[], customerId?: string | number, quantity?: number) => Promise<Record<string, TPriceData>>;
+    getTaxEstimate: (customerId: string | number, postalCode: string, items: TTaxItem[]) => Promise<TTax>;
+}
+/**
+ * Creates server-side pricing actions with Redis caching and edge cache support.
+ *
+ * Uses `withServerCache` which produces cache keys compatible with augur-hooks'
+ * `withCache`, so server-prefetched data is shared with client-side hooks.
+ *
+ * @example
+ * ```ts
+ * // lib/pricing-actions.ts
+ * import { createPricingActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const pricingActions = createPricingActions(getAugurClient(), {
+ *   defaultCustomerId: process.env.NEXT_PUBLIC_DEFAULT_CUSTOMER_ID,
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const price = await pricingActions.getItemPrice("ITEM-1");
+ * const prices = await pricingActions.batchGetItemPrices(["ITEM-1", "ITEM-2"]);
+ * ```
+ */
+declare function createPricingActions(api: PricingApiClient, config?: PricingActionsConfig): PricingActions;
+
+/**
+ * The subset of augur-api used by item actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface ItemsApiClient {
+    items: {
+        categories: {
+            get: (uid: number, params?: Record<string, unknown>) => Promise<{
+                data: TCategory;
+            }>;
+            lookup: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            items: {
+                list: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            attributes: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: {
+                        attributes: TAttribute[];
+                    };
+                }>;
+            };
+        };
+        invMast: {
+            get: (uid: number, params?: Record<string, unknown>) => Promise<{
+                data: TInvMast;
+            }>;
+            doc: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: TInvMastDoc;
+                }>;
+            };
+            stock: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: TStock;
+                }>;
+            };
+            faq: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+            invSub: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+            invAccessory: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: TItemAccessory[];
+                }>;
+            };
+            similar: {
+                list: (uid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+    };
+}
+interface ItemActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value for most calls. Default: 1 (hour). */
+    edgeCache?: number;
+    /** CDN edge cache for rarely-changing data like FAQs. Default: 8 (hours). */
+    longEdgeCache?: number;
+    /** Redis TTL for most calls in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Redis TTL for rarely-changing data in seconds. Default: 28800 (8 hours). */
+    longRedisTtl?: number;
+}
+interface ItemActions {
+    itemCategoryLookup: (path: string) => Promise<unknown>;
+    getItemCategory: (uid: number, options?: Record<string, unknown>) => Promise<TCategory>;
+    getCategoryItems: (uid: number, filters: Record<string, unknown>) => Promise<unknown>;
+    getItemAttributes: (categoryUid: number) => Promise<TAttribute[]>;
+    getInvMast: (uid: number) => Promise<TInvMast>;
+    getInvMastDoc: (params: {
+        invMastUid?: number;
+        itemId?: string;
+    }) => Promise<TInvMastDoc>;
+    getStock: (invMastUid: number) => Promise<TStockData[]>;
+    getStockCompanySummary: (invMastUid: number) => Promise<Record<string, number>>;
+    getItemFaqs: (invMastUid: number) => Promise<unknown[]>;
+    getItemSubstitutes: (invMastUid: number) => Promise<unknown[]>;
+    getItemAccessories: (invMastUid: number) => Promise<TItemAccessory[]>;
+    getSimilarItems: (invMastUid: number) => Promise<unknown[]>;
+    batchGetInvMastDocs: (params: {
+        invMastUid?: number;
+        itemId?: string;
+    }[]) => Promise<Record<string, TInvMastDoc>>;
+    batchGetStockData: (invMastUids: number[]) => Promise<Record<number, TStockData[]>>;
+}
+/**
+ * Creates server-side item actions with Redis caching and edge cache support.
+ *
+ * Uses `withServerCache` which produces cache keys compatible with augur-hooks'
+ * `withCache`, so server-prefetched data is shared with client-side hooks.
+ *
+ * @example
+ * ```ts
+ * // lib/item-actions.ts
+ * import { createItemActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const itemActions = createItemActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const category = await itemActions.getItemCategory(123);
+ * const doc = await itemActions.getInvMastDoc({ itemId: "ITEM-1" });
+ * ```
+ */
+declare function createItemActions(api: ItemsApiClient, config?: ItemActionsConfig): ItemActions;
+
+/**
+ * The subset of augur-api used by commerce actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface CommerceApiClient {
+    commerce: {
+        cartHdr: {
+            lookup: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: TCartLookUp;
+                }>;
+            };
+            alsoBought: {
+                get: (cartHdrUid: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown[];
+                }>;
+            };
+        };
+        cartLine: {
+            get: (cartHdrUid: number) => Promise<{
+                data: TCartLine[];
+            }>;
+            add: {
+                create: (cartHdrUid: number, params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            update: {
+                create: (cartHdrUid: number, params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            delete: (cartHdrUid: number) => Promise<{
+                data: unknown;
+            }>;
+        };
+        checkout: {
+            create: (params: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+    };
+}
+interface CommerceActionsConfig {
+    defaultContactId?: string | number;
+    defaultCustomerId?: string | number;
+    /** Optional UOM conversion function. E.g. (uom) => uom === "EA" ? "EACH" : uom */
+    convertUnitOfMeasure?: (uom: string) => string;
+}
+interface CommerceActions {
+    cartHdrLookup: (params: {
+        userId?: string | number;
+        cartToken?: string;
+        contactId?: string | number;
+        customerId?: string | number;
+    }) => Promise<TCartLookUp>;
+    getCartLines: (cartHdrUid: number) => Promise<TCartLine[]>;
+    addToCart: (cartHdrUid: number, items: {
+        itemId: string;
+        quantity: number;
+        unitOfMeasure: string;
+    }[]) => Promise<unknown>;
+    updateCartLines: (cartHdrUid: number, lines: {
+        lineNo: number;
+        quantity: number;
+        unitOfMeasure: string;
+    }[]) => Promise<unknown>;
+    deleteCartItems: (cartHdrUid: number) => Promise<void>;
+    getCartAlsoBought: (cartHdrUid: number) => Promise<unknown[]>;
+    checkoutOrder: (cartHdrUid: number, data: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Creates server-side commerce actions for cart operations.
+ *
+ * Unlike pricing actions, commerce actions do NOT use caching because
+ * cart operations are real-time and must always reflect current state.
+ *
+ * @example
+ * ```ts
+ * // lib/commerce-actions.ts
+ * import { createCommerceActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const commerceActions = createCommerceActions(getAugurClient(), {
+ *   defaultContactId: process.env.NEXT_PUBLIC_DEFAULT_CONTACT_ID,
+ *   defaultCustomerId: process.env.NEXT_PUBLIC_DEFAULT_CUSTOMER_ID,
+ *   convertUnitOfMeasure: (uom) => uom === "EA" ? "EACH" : uom,
+ * });
+ *
+ * // In a server action:
+ * const cart = await commerceActions.cartHdrLookup({ userId: 123 });
+ * const lines = await commerceActions.getCartLines(cart.cartHdrUid);
+ * ```
+ */
+declare function createCommerceActions(api: CommerceApiClient, config?: CommerceActionsConfig): CommerceActions;
+
+/**
+ * The subset of augur-api used by order actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface OrderApiClient {
+    orders: {
+        oeHdr: {
+            doc: {
+                get: (params: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+        };
+    };
+}
+interface OrderActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL for order doc lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface OrderActions {
+    getOrderDoc: (orderNo: string, zipCode: string) => Promise<unknown>;
+}
+/**
+ * Creates server-side order actions with Redis caching and edge cache support.
+ *
+ * Uses `withServerCache` which produces cache keys compatible with augur-hooks'
+ * `withCache`, so server-prefetched data is shared with client-side hooks.
+ *
+ * @example
+ * ```ts
+ * // lib/order-actions.ts
+ * import { createOrderActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const orderActions = createOrderActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const doc = await orderActions.getOrderDoc("12345", "90210");
+ * ```
+ */
+declare function createOrderActions(api: OrderApiClient, config?: OrderActionsConfig): OrderActions;
+
+/**
+ * The subset of augur-api used by search actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface SearchApiClient {
+    openSearch: {
+        itemSearch: {
+            list: (params: Record<string, unknown>) => Promise<{
+                data: {
+                    items: TProductItem[];
+                    totalResults: number;
+                };
+            }>;
+            attributes: {
+                list: (params: Record<string, unknown>) => Promise<{
+                    data: {
+                        attributes: TAttribute[];
+                    };
+                }>;
+            };
+        };
+        suggestions: {
+            suggest: {
+                list: (params: Record<string, unknown>) => Promise<{
+                    data: {
+                        data: unknown[];
+                        total: number;
+                        totalResults: number;
+                    };
+                }>;
+            };
+        };
+    };
+}
+interface SearchActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL for search lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+    /** Default source fields for item search. Default: "display_desc". */
+    defaultSourceFields?: string;
+}
+/** Paginated response for infinite scroll. */
+interface SearchPage {
+    data: TProductItem[];
+    total: number;
+    nextCursor?: number;
+}
+interface SearchActions {
+    getSearchAttributes: (q: string) => Promise<TAttribute[]>;
+    getSearchSuggestions: (q: string, limit?: number, offset?: number) => Promise<{
+        data: unknown[];
+        total: number;
+        totalResults: number;
+    }>;
+    itemSearch: (filters: {
+        q: string;
+        limit: number;
+        offset: number;
+        sortBy?: string;
+        filters?: [string, string][];
+    }, itemCategoryUid?: number | string) => Promise<{
+        items: TProductItem[];
+        totalResults: number;
+    }>;
+    itemSearchInfinite: (filters: {
+        q: string;
+        limit: number;
+        sortBy?: string;
+        filters?: [string, string][];
+    }, itemCategoryUid?: number | string, pageParam?: number) => Promise<SearchPage>;
+}
+/**
+ * Creates server-side search actions with Redis caching and edge cache support.
+ *
+ * Uses `withServerCache` which produces cache keys compatible with augur-hooks'
+ * `withCache`, so server-prefetched data is shared with client-side hooks.
+ *
+ * @example
+ * ```ts
+ * // lib/search-actions.ts
+ * import { createSearchActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const searchActions = createSearchActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const attrs = await searchActions.getSearchAttributes("widget");
+ * const results = await searchActions.itemSearch({ q: "widget", limit: 20, offset: 0 });
+ * ```
+ */
+declare function createSearchActions(api: SearchApiClient, config?: SearchActionsConfig): SearchActions;
+
+interface ShippingAddress {
+    address1: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country?: string;
+}
+/**
+ * The subset of augur-api used by shipping actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface ShippingApiClient {
+    ups: {
+        ratesShop: {
+            get: (params: Record<string, unknown>) => Promise<{
+                data: unknown;
+            }>;
+        };
+    };
+}
+interface ShippingActionsConfig {
+    /** Warehouse/origin address for rate calculations. */
+    fromAddress: ShippingAddress;
+    /** UPS service codes to filter results. Default: undefined (return all). */
+    defaultServiceCodes?: string[];
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL for shipping rate lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface ShippingActions {
+    getShippingRates: (toAddress: ShippingAddress, weight: number, serviceCodes?: string[]) => Promise<unknown>;
+}
+/**
+ * Creates server-side shipping actions with Redis caching and edge cache support.
+ *
+ * Uses `withServerCache` which produces cache keys compatible with augur-hooks'
+ * `withCache`, so server-prefetched data is shared with client-side hooks.
+ *
+ * @example
+ * ```ts
+ * // lib/shipping-actions.ts
+ * import { createShippingActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const shippingActions = createShippingActions(getAugurClient(), {
+ *   fromAddress: {
+ *     address1: "123 Warehouse Ln",
+ *     city: "Chicago",
+ *     state: "IL",
+ *     postalCode: "60601",
+ *   },
+ * });
+ *
+ * // In a server component:
+ * const rates = await shippingActions.getShippingRates(
+ *   { address1: "456 Main St", city: "Denver", state: "CO", postalCode: "80202" },
+ *   5.0,
+ * );
+ * ```
+ */
+declare function createShippingActions(api: ShippingApiClient, config: ShippingActionsConfig): ShippingActions;
+
+/**
+ * The subset of augur-api used by Joomla content actions.
+ * Avoids importing the full SDK type so augur-server stays lightweight.
+ */
+interface JoomlaApiClient {
+    joomla: {
+        content: {
+            doc: {
+                get: (articleId: number, params?: Record<string, unknown>) => Promise<{
+                    data: unknown;
+                }>;
+            };
+            list: (params?: Record<string, unknown>) => Promise<{
+                data: unknown[];
+            }>;
+        };
+    };
+}
+interface JoomlaActionsConfig {
+    /** Cache key prefix (e.g. "ampro:"). Default: "". */
+    cachePrefix?: string;
+    /** CDN edge cache value passed to SDK. Default: 1 (hour). */
+    edgeCache?: number;
+    /** Redis TTL for Joomla lookups in seconds. Default: 3600 (1 hour). */
+    redisTtl?: number;
+}
+interface JoomlaActions {
+    getJoomlaContent: (articleId: number) => Promise<unknown>;
+    getJoomlaContentList: (params?: Record<string, unknown>) => Promise<unknown[]>;
+}
+/**
+ * Creates server-side Joomla content actions with Redis caching and edge cache support.
+ *
+ * Uses `withServerCache` which produces cache keys compatible with augur-hooks'
+ * `withCache`, so server-prefetched data is shared with client-side hooks.
+ *
+ * @example
+ * ```ts
+ * // lib/joomla-actions.ts
+ * import { createJoomlaActions } from "@simpleapps-com/augur-server";
+ * import { getAugurClient } from "./augur-client";
+ *
+ * export const joomlaActions = createJoomlaActions(getAugurClient(), {
+ *   cachePrefix: "ampro:",
+ * });
+ *
+ * // In a server component:
+ * const article = await joomlaActions.getJoomlaContent(42);
+ * const articles = await joomlaActions.getJoomlaContentList({ catid: 5 });
+ * ```
+ */
+declare function createJoomlaActions(api: JoomlaApiClient, config?: JoomlaActionsConfig): JoomlaActions;
+
+export { type CommerceActions, type CommerceActionsConfig, type CommerceApiClient, type ItemActions, type ItemActionsConfig, type ItemsApiClient, type JoomlaActions, type JoomlaActionsConfig, type JoomlaApiClient, type OrderActions, type OrderActionsConfig, type OrderApiClient, type PricingActions, type PricingActionsConfig, type PricingApiClient, type SearchActions, type SearchActionsConfig, type SearchApiClient, type SearchPage, type ShippingActions, type ShippingActionsConfig, type ShippingAddress, type ShippingApiClient, cacheGet, cacheSet, createCommerceActions, createItemActions, createJoomlaActions, createOrderActions, createPricingActions, createSearchActions, createServerQueryClient, createShippingActions, env, getCircuitState, getServerQueryClient, isDev, isProduction, isRedisConnected, isStaging, sdkCall, withServerCache };