@simpleapps-com/augur-server 0.2.3 → 0.2.5

package/dist/index.js

@@ -2,6 +2,10 @@ import {
   createQueryOptions,
   createSuspenseQueryOptions
 } from "./chunk-I26RJDRF.js";
+import {
+  createServerQueryClient,
+  getServerQueryClient
+} from "./chunk-I7EWYSPA.js";
 
 // src/environment.ts
 function getEnvironment() {
@@ -134,32 +138,602 @@ async function sdkCall(method, ...args) {
   return method(...args);
 }
 
-// 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
-      }
+// src/cache/with-cache.ts
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function stableStringify(value) {
+  if (value === null || value === void 0) return JSON.stringify(value);
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const entries = keys.map(
+    (key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`
+  );
+  return `{${entries.join(",")}}`;
+}
+async function withServerCache(prefix, redisTtl, methodPath, fn, ...keyArgs) {
+  if (!redisTtl) return fn();
+  const key = `${prefix}sdk:${methodPath}:${fnv1a(stableStringify(keyArgs))}`;
+  try {
+    const cached = await cacheGet(key);
+    if (cached != null) return JSON.parse(cached);
+  } catch {
+  }
+  const result = await fn();
+  try {
+    cacheSet(key, JSON.stringify(result), redisTtl).catch(() => {
+    });
+  } catch {
+  }
+  return result;
+}
+
+// src/actions/pricing.ts
+function resolveCustomerId(explicit, fallback) {
+  const raw = explicit ?? fallback;
+  const num = Number(raw);
+  return num > 0 ? num : 0;
+}
+function createPricingActions(api, config = {}) {
+  const {
+    defaultCustomerId,
+    cachePrefix = "",
+    edgeCache = 2,
+    redisTtl = 3600,
+    taxRedisTtl = 1800
+  } = config;
+  async function getItemPrice(itemId, customerId, quantity = 1) {
+    const custId = resolveCustomerId(customerId, defaultCustomerId);
+    const params = { customerId: custId, itemId, quantity, edgeCache };
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "pricing.priceEngine.get",
+      async () => {
+        const response = await api.pricing.priceEngine.get(params);
+        return response.data;
+      },
+      params
+    );
+  }
+  async function batchGetItemPrices(itemIds, customerId, quantity = 1) {
+    const results = await Promise.all(
+      itemIds.map((id) => getItemPrice(id, customerId, quantity).then((data) => [id, data]).catch(() => [id, null]))
+    );
+    const out = {};
+    for (const [id, data] of results) {
+      if (data) out[id] = data;
+    }
+    return out;
+  }
+  async function getTaxEstimate(customerId, postalCode, items) {
+    const custId = resolveCustomerId(customerId, defaultCustomerId);
+    const params = { customerId: custId, postalCode, items };
+    return withServerCache(
+      cachePrefix,
+      taxRedisTtl,
+      "pricing.taxEngine.create",
+      async () => {
+        const response = await api.pricing.taxEngine.create(params);
+        return response.data;
+      },
+      params
+    );
+  }
+  return { getItemPrice, batchGetItemPrices, getTaxEstimate };
+}
+
+// src/actions/items.ts
+function createItemActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    longEdgeCache = 8,
+    redisTtl = 3600,
+    longRedisTtl = 28800
+  } = config;
+  async function itemCategoryLookup(path) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.categories.lookup.get",
+      async () => {
+        const response = await api.items.categories.lookup.get({
+          path,
+          edgeCache
+        });
+        return response.data;
+      },
+      path
+    );
+  }
+  async function getItemCategory(uid, options) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.categories.get",
+      async () => {
+        const response = await api.items.categories.get(uid, {
+          ...options,
+          edgeCache
+        });
+        return response.data;
+      },
+      uid,
+      options
+    );
+  }
+  async function getCategoryItems(uid, filters) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.categories.items.list",
+      async () => {
+        const response = await api.items.categories.items.list({
+          ...filters,
+          itemCategoryUid: uid,
+          edgeCache
+        });
+        return response.data;
+      },
+      uid,
+      filters
+    );
+  }
+  async function getItemAttributes(categoryUid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.categories.attributes.list",
+      async () => {
+        const response = await api.items.categories.attributes.list(
+          categoryUid,
+          { edgeCache }
+        );
+        return response.data.attributes;
+      },
+      categoryUid
+    );
+  }
+  async function getInvMast(uid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.invMast.get",
+      async () => {
+        const response = await api.items.invMast.get(uid, { edgeCache: 4 });
+        return response.data;
+      },
+      uid
+    );
+  }
+  async function getInvMastDoc(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.invMast.doc.list",
+      async () => {
+        const response = await api.items.invMast.doc.list(
+          params.invMastUid ?? 0,
+          { itemId: params.itemId, edgeCache: 4 }
+        );
+        return response.data;
+      },
+      params.invMastUid,
+      params.itemId
+    );
+  }
+  async function getStock(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.invMast.stock.list",
+      async () => {
+        const response = await api.items.invMast.stock.list(invMastUid, {
+          edgeCache
+        });
+        return response.data?.stockData;
+      },
+      invMastUid
+    );
+  }
+  async function getStockCompanySummary(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.invMast.stock.list.companySummary",
+      async () => {
+        const response = await api.items.invMast.stock.list(invMastUid, {
+          edgeCache
+        });
+        return response.data?.companySummary;
+      },
+      invMastUid
+    );
+  }
+  async function getItemFaqs(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "items.invMast.faq.list",
+      async () => {
+        const response = await api.items.invMast.faq.list(invMastUid, {
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      invMastUid
+    );
+  }
+  async function getItemSubstitutes(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "items.invMast.invSub.list",
+      async () => {
+        const response = await api.items.invMast.invSub.list(invMastUid, {
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      invMastUid
+    );
+  }
+  async function getItemAccessories(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "items.invMast.invAccessory.list",
+      async () => {
+        const response = await api.items.invMast.invAccessory.list(
+          invMastUid,
+          { edgeCache }
+        );
+        return response.data;
+      },
+      invMastUid
+    );
+  }
+  async function getSimilarItems(invMastUid) {
+    return withServerCache(
+      cachePrefix,
+      longRedisTtl,
+      "items.invMast.similar.list",
+      async () => {
+        const response = await api.items.invMast.similar.list(invMastUid, {
+          edgeCache: longEdgeCache
+        });
+        return response.data;
+      },
+      invMastUid
+    );
+  }
+  async function batchGetInvMastDocs(params) {
+    const results = await Promise.all(
+      params.map(
+        (p) => getInvMastDoc(p).then((data) => [p.itemId ?? String(p.invMastUid), data]).catch(() => [p.itemId ?? String(p.invMastUid), void 0])
+      )
+    );
+    const out = {};
+    for (const [key, data] of results) {
+      if (data) out[key] = data;
+    }
+    return out;
+  }
+  async function batchGetStockData(invMastUids) {
+    const results = await Promise.all(
+      invMastUids.map(
+        (uid) => getStock(uid).then((data) => [uid, data]).catch(() => [uid, void 0])
+      )
+    );
+    const out = {};
+    for (const [uid, data] of results) {
+      if (data) out[uid] = data;
+    }
+    return out;
+  }
+  return {
+    itemCategoryLookup,
+    getItemCategory,
+    getCategoryItems,
+    getItemAttributes,
+    getInvMast,
+    getInvMastDoc,
+    getStock,
+    getStockCompanySummary,
+    getItemFaqs,
+    getItemSubstitutes,
+    getItemAccessories,
+    getSimilarItems,
+    batchGetInvMastDocs,
+    batchGetStockData
+  };
+}
+
+// src/actions/commerce.ts
+function createCommerceActions(api, config = {}) {
+  const { defaultContactId, defaultCustomerId, convertUnitOfMeasure } = config;
+  async function cartHdrLookup(params) {
+    const lookupParams = { ...params };
+    if (lookupParams.contactId == null && defaultContactId != null) {
+      lookupParams.contactId = defaultContactId;
+    }
+    if (lookupParams.customerId == null && defaultCustomerId != null) {
+      lookupParams.customerId = defaultCustomerId;
+    }
+    const response = await api.commerce.cartHdr.lookup.get(lookupParams);
+    return response.data;
+  }
+  async function getCartLines(cartHdrUid) {
+    const response = await api.commerce.cartLine.get(cartHdrUid);
+    return response.data;
+  }
+  async function addToCart(cartHdrUid, items) {
+    try {
+      const mappedItems = items.map((item) => ({
+        ...item,
+        unitOfMeasure: convertUnitOfMeasure ? convertUnitOfMeasure(item.unitOfMeasure) : item.unitOfMeasure
+      }));
+      const response = await api.commerce.cartLine.add.create(
+        cartHdrUid,
+        { items: mappedItems }
+      );
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function updateCartLines(cartHdrUid, lines) {
+    try {
+      const mappedLines = lines.map((line) => ({
+        ...line,
+        unitOfMeasure: convertUnitOfMeasure ? convertUnitOfMeasure(line.unitOfMeasure) : line.unitOfMeasure
+      }));
+      const response = await api.commerce.cartLine.update.create(
+        cartHdrUid,
+        { lines: mappedLines }
+      );
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  async function deleteCartItems(cartHdrUid) {
+    try {
+      await api.commerce.cartLine.delete(cartHdrUid);
+    } catch {
     }
-  });
+  }
+  async function getCartAlsoBought(cartHdrUid) {
+    const response = await api.commerce.cartHdr.alsoBought.get(cartHdrUid);
+    return response.data;
+  }
+  async function checkoutOrder(cartHdrUid, data) {
+    try {
+      const response = await api.commerce.checkout.create({
+        ...data,
+        cartHdrUid
+      });
+      return response.data;
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    cartHdrLookup,
+    getCartLines,
+    addToCart,
+    updateCartLines,
+    deleteCartItems,
+    getCartAlsoBought,
+    checkoutOrder
+  };
+}
+
+// src/actions/orders.ts
+function createOrderActions(api, config = {}) {
+  const { cachePrefix = "", edgeCache = 1, redisTtl = 3600 } = config;
+  async function getOrderDoc(orderNo, zipCode) {
+    const params = { orderNo, zipCode, edgeCache };
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "orders.oeHdr.doc.get",
+      async () => {
+        const response = await api.orders.oeHdr.doc.get(params);
+        return response.data;
+      },
+      params
+    );
+  }
+  return { getOrderDoc };
+}
+
+// src/actions/search.ts
+function createSearchActions(api, config = {}) {
+  const {
+    cachePrefix = "",
+    edgeCache = 1,
+    redisTtl = 3600,
+    defaultSourceFields = "display_desc"
+  } = config;
+  async function getSearchAttributes(q) {
+    const params = { q, edgeCache };
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "openSearch.itemSearch.attributes.list",
+      async () => {
+        const response = await api.openSearch.itemSearch.attributes.list(params);
+        return response.data.attributes;
+      },
+      q
+    );
+  }
+  async function getSearchSuggestions(q, limit, offset) {
+    const params = { q, edgeCache };
+    if (limit !== void 0) params.size = limit;
+    if (offset !== void 0) params.from = offset;
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "openSearch.suggestions.suggest.list",
+      async () => {
+        const response = await api.openSearch.suggestions.suggest.list(params);
+        return response.data;
+      },
+      q
+    );
+  }
+  async function itemSearch(filters, itemCategoryUid) {
+    const params = {
+      q: filters.q,
+      searchType: "query",
+      size: filters.limit,
+      from: filters.offset,
+      sortBy: filters.sortBy,
+      classId5List: itemCategoryUid ? String(itemCategoryUid) : void 0,
+      filters: filters.filters?.length ? JSON.stringify(filters.filters) : void 0,
+      sourceFieldsList: defaultSourceFields,
+      edgeCache
+    };
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "openSearch.itemSearch.list",
+      async () => {
+        const response = await api.openSearch.itemSearch.list(params);
+        return response.data;
+      },
+      filters,
+      itemCategoryUid
+    );
+  }
+  async function itemSearchInfinite(filters, itemCategoryUid, pageParam = 0) {
+    const params = {
+      q: filters.q,
+      searchType: "query",
+      size: filters.limit,
+      from: pageParam,
+      sortBy: filters.sortBy,
+      classId5List: itemCategoryUid ? String(itemCategoryUid) : void 0,
+      filters: filters.filters?.length ? JSON.stringify(filters.filters) : void 0,
+      sourceFieldsList: defaultSourceFields,
+      edgeCache
+    };
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "openSearch.itemSearch.list",
+      async () => {
+        const response = await api.openSearch.itemSearch.list(params);
+        const { items, totalResults } = response.data;
+        const nextOffset = pageParam + filters.limit;
+        return {
+          data: items,
+          total: totalResults,
+          nextCursor: nextOffset < totalResults ? nextOffset : void 0
+        };
+      },
+      filters,
+      itemCategoryUid,
+      pageParam
+    );
+  }
+  return {
+    getSearchAttributes,
+    getSearchSuggestions,
+    itemSearch,
+    itemSearchInfinite
+  };
+}
+
+// src/actions/shipping.ts
+function createShippingActions(api, config) {
+  const {
+    fromAddress,
+    defaultServiceCodes,
+    cachePrefix = "",
+    edgeCache = 1,
+    redisTtl = 3600
+  } = config;
+  async function getShippingRates(toAddress, weight, serviceCodes) {
+    const params = {
+      fromAddress,
+      toAddress: { ...toAddress, country: toAddress.country ?? "US" },
+      weight,
+      serviceCodes: serviceCodes ?? defaultServiceCodes,
+      edgeCache
+    };
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "ups.ratesShop.get",
+      async () => {
+        const response = await api.ups.ratesShop.get(params);
+        return response.data;
+      },
+      params
+    );
+  }
+  return { getShippingRates };
+}
+
+// src/actions/joomla.ts
+function createJoomlaActions(api, config = {}) {
+  const { cachePrefix = "", edgeCache = 1, redisTtl = 3600 } = config;
+  async function getJoomlaContent(articleId) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "joomla.content.doc.get",
+      async () => {
+        const response = await api.joomla.content.doc.get(articleId, {
+          edgeCache
+        });
+        return response.data;
+      },
+      articleId
+    );
+  }
+  async function getJoomlaContentList(params) {
+    return withServerCache(
+      cachePrefix,
+      redisTtl,
+      "joomla.content.list",
+      async () => {
+        const response = await api.joomla.content.list({
+          ...params,
+          edgeCache
+        });
+        return response.data;
+      },
+      params
+    );
+  }
+  return { getJoomlaContent, getJoomlaContentList };
 }
-var getServerQueryClient = cache(
-  () => createServerQueryClient()
-);
 export {
   cacheGet,
   cacheSet,
+  createCommerceActions,
+  createItemActions,
+  createJoomlaActions,
+  createOrderActions,
+  createPricingActions,
   createQueryOptions,
+  createSearchActions,
   createServerQueryClient,
+  createShippingActions,
   createSuspenseQueryOptions,
   env,
   getCircuitState,
@@ -168,6 +742,7 @@ export {
   isProduction,
   isRedisConnected,
   isStaging,
-  sdkCall
+  sdkCall,
+  withServerCache
 };
 //# sourceMappingURL=index.js.map