@reactionary/feeds 0.0.1

package/lib/env-client-builder.js

@@ -0,0 +1,244 @@
+import { withAlgoliaCapabilities } from "@reactionary/algolia";
+import {
+  withCommercetoolsCapabilities
+} from "@reactionary/commercetools";
+import {
+  ClientBuilder,
+  MemoryCache,
+  createInitialRequestContext
+} from "@reactionary/core";
+import { withFakeCapabilities } from "@reactionary/fake";
+import { withMagentoCapabilities } from "@reactionary/magento";
+import { withMedusaCapabilities } from "@reactionary/medusa";
+import {
+  withMeilisearchCapabilities
+} from "@reactionary/meilisearch";
+import { loadCwdEnv } from "./load-cwd-env.js";
+const providerSystems = [
+  "FAKE",
+  "MAGENTO",
+  "MEDUSA",
+  "COMMERCETOOLS",
+  "ALGOLIA",
+  "MEILISEARCH",
+  "UNOMI"
+];
+function createReactionaryFeedClientFromEnv(options = {}) {
+  if (options.loadEnv !== false) {
+    loadCwdEnv({
+      env: options.env
+    });
+  }
+  const env = options.env ?? process.env;
+  const enabledSystems = getEnabledReactionaryFeedProviderSystems(env);
+  if (enabledSystems.length === 0) {
+    throw new Error(getNoEnabledProviderSystemsMessage());
+  }
+  const context = {
+    ...createInitialRequestContext(),
+    ...options.contextOverrides
+  };
+  let builder = new ClientBuilder(context).withCache(
+    options.cache ?? new MemoryCache()
+  );
+  for (const system of enabledSystems) {
+    switch (system) {
+      case "ALGOLIA":
+        builder = builder.withCapability(
+          withAlgoliaCapabilities(getAlgoliaConfiguration(env), {
+            productSearch: { enabled: true }
+          })
+        );
+        break;
+      case "COMMERCETOOLS":
+        builder = builder.withCapability(
+          withCommercetoolsCapabilities(getCommercetoolsConfiguration(env), {
+            product: { enabled: true },
+            category: { enabled: true },
+            inventory: { enabled: true },
+            price: { enabled: true },
+            productSearch: { enabled: true },
+            productReviews: { enabled: true },
+            store: { enabled: true }
+          })
+        );
+        break;
+      case "FAKE":
+        builder = builder.withCapability(
+          withFakeCapabilities(getFakeConfiguration(), {
+            productSearch: { enabled: true },
+            category: { enabled: true },
+            store: { enabled: true },
+            price: { enabled: true },
+            inventory: { enabled: true },
+            product: { enabled: true },
+            productReviews: { enabled: true }
+          })
+        );
+        break;
+      case "MAGENTO":
+        builder = builder.withCapability(
+          withMagentoCapabilities(getMagentoConfiguration(env), {
+            product: { enabled: true },
+            category: { enabled: true },
+            inventory: { enabled: true },
+            price: { enabled: true },
+            productSearch: { enabled: true },
+            productReviews: { enabled: true }
+          })
+        );
+        break;
+      case "MEDUSA":
+        builder = builder.withCapability(
+          withMedusaCapabilities(getMedusaConfiguration(env), {
+            product: { enabled: true },
+            category: { enabled: true },
+            inventory: { enabled: true },
+            price: { enabled: true },
+            productSearch: { enabled: true }
+          })
+        );
+        break;
+      case "MEILISEARCH":
+        builder = builder.withCapability(
+          withMeilisearchCapabilities(getMeilisearchConfiguration(env), {
+            productSearch: { enabled: true }
+          })
+        );
+        break;
+      case "UNOMI":
+        break;
+    }
+  }
+  return {
+    client: builder.build(),
+    enabledSystems
+  };
+}
+function createReactionaryFeedClientFactoryFromEnv(options = {}) {
+  return (requestContext) => createReactionaryFeedClientFromEnv({
+    ...options,
+    contextOverrides: requestContext
+  }).client;
+}
+function getEnabledReactionaryFeedProviderSystems(env = process.env) {
+  return providerSystems.filter(
+    (system) => isEnvEnabled(env[`ENABLED_${system}`])
+  );
+}
+function getNoEnabledProviderSystemsMessage() {
+  return `No Reactionary provider system is enabled. Set one of ${providerSystems.map((system) => `ENABLED_${system}=true`).join(", ")}.`;
+}
+function parseCommaSeparatedEnvList(value) {
+  return (value || "").split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function isEnvEnabled(value) {
+  return value?.toLowerCase() === "true";
+}
+function getAlgoliaConfiguration(env) {
+  return {
+    apiKey: env["ALGOLIA_API_KEY"] || "",
+    appId: env["ALGOLIA_APP_ID"] || "",
+    indexName: env["ALGOLIA_INDEX"] || "",
+    useRecommendationsForBots: env["ALGOLIA_USE_RECOMMENDATIONS_FOR_BOTS"] === "true",
+    useBaseIndexNameForEnglishLocale: env["ALGOLIA_USE_BASE_INDEX_NAME_FOR_ENGLISH_LOCALE"] === "true"
+  };
+}
+function getCommercetoolsConfiguration(env) {
+  return {
+    apiUrl: env["CTP_API_URL"] || "",
+    authUrl: env["CTP_AUTH_URL"] || "",
+    clientId: env["CTP_CLIENT_ID"] || "",
+    clientSecret: env["CTP_CLIENT_SECRET"] || "",
+    projectKey: env["CTP_PROJECT_KEY"] || "",
+    scopes: parseCommaSeparatedEnvList(env["CTP_SCOPES"]),
+    paymentMethods: [
+      {
+        identifier: {
+          method: "stripe",
+          name: "Stripe",
+          paymentProcessor: "stripe"
+        },
+        isPunchOut: false,
+        description: "Stripe payment gateway"
+      }
+    ],
+    facetFieldsForSearch: parseCommaSeparatedEnvList(
+      env["CTP_FACET_FIELDS_FOR_SEARCH"]
+    ),
+    adminClientId: env["CTP_ADMIN_CLIENT_ID"] || void 0,
+    adminClientSecret: env["CTP_ADMIN_CLIENT_SECRET"] || void 0,
+    listPriceChannelKey: env["CTP_LIST_PRICE_CHANNEL_KEY"] || void 0,
+    customerPriceChannelKey: env["CTP_CUSTOMER_PRICE_CHANNEL_KEY"] || void 0
+  };
+}
+function getFakeConfiguration() {
+  return {
+    jitter: {
+      mean: 0,
+      deviation: 0
+    },
+    seeds: {
+      product: 1,
+      search: 1,
+      category: 1
+    },
+    featureFlags: {
+      flags: [
+        {
+          key: "true-flag",
+          type: "boolean",
+          enabled: true
+        },
+        {
+          key: "string-flag",
+          type: "multivariate",
+          variants: ["red", "green", "blue"],
+          enabledVariant: "blue"
+        }
+      ]
+    }
+  };
+}
+function getMagentoConfiguration(env) {
+  return {
+    adminApiKey: env["MAGENTO_ADMIN_API_KEY"] || "",
+    baseUrl: env["MAGENTO_BASE_URL"] || "",
+    storeCode: env["MAGENTO_STORE_CODE"] || "",
+    authStoreCode: env["MAGENTO_AUTH_STORE_CODE"] || "default",
+    mediaUrl: env["MAGENTO_MEDIA_URL"] || void 0,
+    mediaSource: env["MAGENTO_MEDIA_SOURCE"] === "EXTERNAL" ? "EXTERNAL" : "DEFAULT",
+    defaultCurrency: env["MAGENTO_DEFAULT_CURRENCY"] || "",
+    rootCategoryId: env["MAGENTO_ROOT_CATEGORY_ID"] || "2",
+    graphqlUrl: env["MAGENTO_GRAPHQL_URL"] || void 0,
+    reviewRatingCode: env["MAGENTO_REVIEW_RATING_CODE"] || void 0,
+    allCurrencies: []
+  };
+}
+function getMedusaConfiguration(env) {
+  return {
+    publishable_key: env["MEDUSA_PUBLISHABLE_KEY"] || "",
+    adminApiKey: env["MEDUSA_ADMIN_KEY"] || "",
+    apiUrl: env["MEDUSA_API_URL"] || "",
+    defaultCurrency: env["MEDUSA_DEFAULT_CURRENCY"] || "",
+    allCurrencies: []
+  };
+}
+function getMeilisearchConfiguration(env) {
+  return {
+    apiKey: env["MEILISEARCH_API_KEY"] || "",
+    apiUrl: env["MEILISEARCH_API_URL"] || "",
+    indexName: env["MEILISEARCH_INDEX"] || "",
+    useAIEmbedding: env["MEILISEARCH_USE_AI_EMBEDDING"] || void 0,
+    semanticRatio: env["MEILISEARCH_SEMANTIC_RATIO"] ? parseFloat(env["MEILISEARCH_SEMANTIC_RATIO"]) : 0.5,
+    orderIndexName: env["MEILISEARCH_ORDER_INDEX"] || "order",
+    useRecommendationsForBots: env["MEILISEARCH_USE_RECOMMENDATIONS_FOR_BOTS"] === "true"
+  };
+}
+export {
+  createReactionaryFeedClientFactoryFromEnv,
+  createReactionaryFeedClientFromEnv,
+  getEnabledReactionaryFeedProviderSystems,
+  getNoEnabledProviderSystemsMessage,
+  parseCommaSeparatedEnvList
+};

package/lib/feed-generator.js

@@ -0,0 +1,395 @@
+import {
+  assertReactionaryFeedClient
+} from "./feed-types.js";
+class ReactionaryFeedGenerator {
+  constructor(client, options = {}) {
+    this.options = options;
+    assertReactionaryFeedClient(client);
+    this.client = client;
+  }
+  options;
+  client;
+  async *products(feed, requestContext) {
+    requestContext.languageContext = feed.languageContext;
+    const pageSize = feed.pageSize ?? feed.search.paginationOptions.pageSize ?? 50;
+    const maxPages = feed.maxPages ?? 100;
+    const productConcurrency = normalizeProductConcurrency(
+      this.options.productConcurrency
+    );
+    const startedAt = Date.now();
+    let processedProducts = 0;
+    let totalProducts = void 0;
+    let pageNumber = 1;
+    this.reportProgress({
+      phase: "searching",
+      processedProducts,
+      elapsedMs: Date.now() - startedAt
+    });
+    while (pageNumber <= maxPages) {
+      const result = await unwrapFeedResult(
+        this.client.productSearch.queryByTerm({
+          search: {
+            ...feed.search,
+            paginationOptions: {
+              ...feed.search.paginationOptions,
+              pageNumber,
+              pageSize
+            }
+          }
+        })
+      );
+      totalProducts = estimateTotalProducts(result, pageSize, maxPages);
+      const totalPages = Math.min(result.totalPages, maxPages);
+      this.reportProgress({
+        phase: "generating",
+        processedProducts,
+        totalProducts,
+        pageNumber,
+        totalPages,
+        elapsedMs: Date.now() - startedAt
+      });
+      for (const batch of chunks(result.items, productConcurrency)) {
+        const products = await Promise.all(
+          batch.map((item) => this.toFeedProduct(item, feed))
+        );
+        for (const product of products) {
+          if (product) {
+            processedProducts += 1;
+            this.reportProgress({
+              phase: "generating",
+              processedProducts,
+              totalProducts,
+              pageNumber,
+              totalPages,
+              elapsedMs: Date.now() - startedAt
+            });
+            yield product;
+          }
+        }
+      }
+      if (pageNumber >= result.totalPages || result.items.length === 0) {
+        this.reportProgress({
+          phase: "completed",
+          processedProducts,
+          totalProducts,
+          pageNumber,
+          totalPages,
+          elapsedMs: Date.now() - startedAt
+        });
+        return;
+      }
+      pageNumber += 1;
+    }
+    this.reportProgress({
+      phase: "completed",
+      processedProducts,
+      totalProducts,
+      pageNumber: pageNumber - 1,
+      totalPages: totalProducts === void 0 ? void 0 : maxPages,
+      elapsedMs: Date.now() - startedAt
+    });
+  }
+  async toFeedProduct(item, feed) {
+    const firstVariant = item.variants[0]?.variant;
+    if (!firstVariant) {
+      return void 0;
+    }
+    const productResult = await this.client.product.getBySKU({
+      variant: firstVariant
+    });
+    const product = productResult.success ? productResult.value : void 0;
+    const variants = await Promise.all(
+      item.variants.map(
+        (variant) => this.toFeedVariant(item, product, variant.variant.sku, feed)
+      )
+    );
+    const images = uniqueImages([
+      ...toFeedImages(product?.mainVariant.images ?? []),
+      ...item.variants.flatMap((variant) => toFeedImages([variant.image]))
+    ]);
+    const [categoryPath, reviewData] = product ? await Promise.all([
+      this.getCategoryPath(product),
+      this.getReviewData(product)
+    ]) : [void 0, void 0];
+    return {
+      id: product?.identifier.key ?? item.identifier.key,
+      title: product?.name ?? item.name,
+      description: product?.description || product?.longDescription,
+      url: toProductUrl(product?.slug ?? item.slug, feed),
+      brand: product?.brand,
+      manufacturer: product?.manufacturer,
+      ...categoryPath && categoryPath.length > 0 ? { categoryPath } : {},
+      ...reviewData?.ratingSummary ? { ratingSummary: reviewData.ratingSummary } : {},
+      ...reviewData?.reviews?.length ? { reviews: reviewData.reviews } : {},
+      images,
+      variants
+    };
+  }
+  async toFeedVariant(item, product, sku, feed) {
+    const variant = product?.variants.find(
+      (productVariant) => productVariant.identifier.sku === sku
+    ) ?? product?.mainVariant;
+    const [customerPriceResult, listPriceResult, inventory] = await Promise.all([
+      this.client.price.getCustomerPrice({ variant: { sku } }),
+      this.client.price.getListPrice({ variant: { sku } }),
+      this.getInventoryBySKU(sku, feed)
+    ]);
+    const customerPrice = customerPriceResult.success ? {
+      value: customerPriceResult.value.unitPrice.value,
+      currency: customerPriceResult.value.unitPrice.currency
+    } : void 0;
+    const listPrice = listPriceResult.success ? {
+      value: listPriceResult.value.unitPrice.value,
+      currency: listPriceResult.value.unitPrice.currency
+    } : void 0;
+    const availability = inventory ? toFeedAvailability(inventory) : void 0;
+    return {
+      id: sku,
+      title: variant?.name || item.name,
+      description: product?.description,
+      url: toProductUrl(product?.slug ?? item.slug, feed),
+      ...variant?.ean ? { ean: variant.ean } : {},
+      ...variant?.gtin ? { gtin: variant.gtin } : {},
+      ...variant?.upc ? { upc: variant.upc } : {},
+      ...variant?.barcode ? { barcode: variant.barcode } : {},
+      manufacturerPartNumber: sku,
+      images: uniqueImages(toFeedImages(variant?.images ?? [])),
+      price: customerPrice,
+      listPrice,
+      availability,
+      barcodes: toFeedBarcodes(variant),
+      options: variant?.options.map((option) => ({
+        name: option.name,
+        value: option.value.label || option.value.identifier.key
+      })) ?? []
+    };
+  }
+  async getInventoryBySKU(sku, feed) {
+    const fulfillmentCenterKeys = getFulfillmentCenterKeys(
+      feed,
+      this.options.defaultFulfillmentCenterKeys
+    );
+    const inventoryResults = await Promise.all(
+      fulfillmentCenterKeys.map(
+        (fulfillmentCenterKey) => this.client.inventory.getBySKU({
+          variant: { sku },
+          fulfilmentCenter: {
+            key: fulfillmentCenterKey
+          }
+        })
+      )
+    );
+    const inventories = inventoryResults.filter((result) => result.success).map((result) => result.value);
+    if (inventories.length === 0) {
+      return void 0;
+    }
+    if (inventories.length === 1) {
+      return inventories[0];
+    }
+    return combineInventory(sku, inventories);
+  }
+  async getCategoryPath(product) {
+    const category = this.client.category;
+    const getBreadcrumbPathToCategory = category?.getBreadcrumbPathToCategory;
+    const parentCategory = product.parentCategories[0];
+    if (!getBreadcrumbPathToCategory || !parentCategory) {
+      return void 0;
+    }
+    const result = await getBreadcrumbPathToCategory.call(category, {
+      id: parentCategory
+    });
+    if (!result.success) {
+      throw new Error(JSON.stringify(result.error));
+    }
+    return result.value.map(toFeedCategory);
+  }
+  async getReviewData(product) {
+    const productReviews = this.client.productReviews;
+    if (!productReviews) {
+      return void 0;
+    }
+    const [summaryResult, reviewsResult] = await Promise.all([
+      productReviews.getRatingSummary({
+        product: product.identifier
+      }),
+      productReviews.findReviews({
+        product: product.identifier,
+        paginationOptions: {
+          pageNumber: 1,
+          pageSize: 3
+        }
+      })
+    ]);
+    if (!summaryResult.success) {
+      throw new Error(JSON.stringify(summaryResult.error));
+    }
+    if (!reviewsResult.success) {
+      throw new Error(JSON.stringify(reviewsResult.error));
+    }
+    return {
+      ratingSummary: toFeedRatingSummary(summaryResult.value),
+      reviews: reviewsResult.value.items.map(toFeedReview)
+    };
+  }
+  reportProgress(progress) {
+    this.options.onProgress?.(progress);
+  }
+}
+async function unwrapFeedResult(resultPromise) {
+  const result = await resultPromise;
+  if (!result.success) {
+    throw new Error(JSON.stringify(result.error));
+  }
+  return result.value;
+}
+function toFeedAvailability(inventory) {
+  return {
+    available: inventory.status === "inStock" && inventory.quantity > 0,
+    status: toFeedAvailabilityStatus(inventory.status),
+    quantity: inventory.quantity
+  };
+}
+function toFeedCategory(category) {
+  return {
+    id: category.identifier.key,
+    name: category.name,
+    ...category.slug ? { slug: category.slug } : {}
+  };
+}
+function toFeedRatingSummary(summary) {
+  return {
+    averageRating: summary.averageRating,
+    ...summary.totalRatings !== void 0 ? { totalRatings: summary.totalRatings } : {},
+    ...summary.ratingDistribution ? { ratingDistribution: summary.ratingDistribution } : {}
+  };
+}
+function toFeedReview(review) {
+  return {
+    id: review.identifier.key,
+    authorName: review.authorName,
+    rating: review.rating,
+    title: review.title,
+    content: review.content,
+    createdAt: review.createdAt,
+    verified: review.verified
+  };
+}
+function estimateTotalProducts(result, pageSize, maxPages) {
+  return Math.min(result.totalCount, Math.min(result.totalPages, maxPages) * pageSize);
+}
+function normalizeProductConcurrency(value) {
+  if (!value || !Number.isFinite(value)) {
+    return 10;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function chunks(items, size) {
+  const result = [];
+  for (let index = 0; index < items.length; index += size) {
+    result.push(items.slice(index, index + size));
+  }
+  return result;
+}
+function toFeedAvailabilityStatus(status) {
+  switch (status) {
+    case "inStock":
+      return "in_stock";
+    case "onBackOrder":
+      return "backorder";
+    case "preOrder":
+      return "preorder";
+    case "discontinued":
+      return "discontinued";
+    case "outOfStock":
+    default:
+      return "out_of_stock";
+  }
+}
+function getFulfillmentCenterKeys(feed, defaultFulfillmentCenterKeys) {
+  const keys = feed.fulfillmentCenterKeys?.length ? feed.fulfillmentCenterKeys : feed.fulfillmentCenterKey ? [feed.fulfillmentCenterKey] : defaultFulfillmentCenterKeys?.length ? defaultFulfillmentCenterKeys : [""];
+  return [...new Set(keys.map((key) => key.trim()))];
+}
+function combineInventory(sku, inventories) {
+  return {
+    identifier: {
+      variant: { sku },
+      fulfillmentCenter: {
+        key: inventories.map(
+          (inventory) => inventory.identifier.fulfillmentCenter.key
+        ).join(",")
+      }
+    },
+    quantity: inventories.reduce((total, inventory) => total + inventory.quantity, 0),
+    status: getCombinedInventoryStatus(inventories)
+  };
+}
+function getCombinedInventoryStatus(inventories) {
+  if (inventories.some(
+    (inventory) => inventory.status === "inStock" && inventory.quantity > 0
+  )) {
+    return "inStock";
+  }
+  if (inventories.some((inventory) => inventory.status === "onBackOrder")) {
+    return "onBackOrder";
+  }
+  if (inventories.some((inventory) => inventory.status === "preOrder")) {
+    return "preOrder";
+  }
+  if (inventories.every((inventory) => inventory.status === "discontinued")) {
+    return "discontinued";
+  }
+  return "outOfStock";
+}
+function toFeedImages(images) {
+  return images.filter((image) => image.sourceUrl.length > 0).map((image) => ({
+    url: image.sourceUrl,
+    ...image.altText ? { altText: image.altText } : {}
+  }));
+}
+function uniqueImages(images) {
+  const seen = /* @__PURE__ */ new Set();
+  return images.filter((image) => {
+    if (seen.has(image.url)) {
+      return false;
+    }
+    seen.add(image.url);
+    return true;
+  });
+}
+function toFeedBarcodes(variant) {
+  if (!variant) {
+    return [];
+  }
+  return [
+    ["ean", variant.ean],
+    ["gtin", variant.gtin],
+    ["upc", variant.upc],
+    ["barcode", variant.barcode]
+  ].filter(([, value]) => value.length > 0).map(([type, value]) => ({
+    type,
+    value
+  }));
+}
+function toProductUrl(slug, feed) {
+  if (!slug || !feed.productUrlBase) {
+    return void 0;
+  }
+  if (feed.productUrlBase.includes("{slug}") || feed.productUrlBase.includes("{lang}")) {
+    return feed.productUrlBase.replaceAll("{lang}", getLanguage(feed.languageContext)).replaceAll("{slug}", encodeURIComponent(slug));
+  }
+  return new URL(slug, feed.productUrlBase).href;
+}
+function getLanguage(feed) {
+  const [language] = feed.locale.split("-");
+  return language.toLowerCase();
+}
+function getTargetCountry(feed) {
+  const [, region] = feed.locale.split("-");
+  return region?.toUpperCase();
+}
+export {
+  ReactionaryFeedGenerator,
+  getLanguage,
+  getTargetCountry,
+  toProductUrl
+};