@moneylion/react-native-offer-carousel 1.0.0

package/src/services/getDynamicOffers.ts

@@ -0,0 +1,93 @@
+import { isEmpty } from "radash";
+import type { CnfContext } from "../../capabilities/core/src/system/cnfContext/CnfContext";
+import type {
+	PartnerOverride,
+	ProductTypeDefinition,
+} from "../../capabilities/offer-catalog/src";
+import {
+	addClientTagsToOfferLinks,
+	getOffersByProductTypes,
+	selectDynamicOffers,
+	type Layout,
+} from "../utils";
+import type {
+	GetProductTypesProps,
+	ProductTypesResult,
+} from "./getProductTypes";
+import { sortOffersByRecommendationScore } from "../utils/sortOffersByRecommendationScore";
+import { pipe } from "effect";
+import { formatOfferUrl } from "../utils/formatOfferUrl";
+import { getOffersBasedOnLayout } from "../utils/getOffersBasedOnLayout";
+
+export type GetDynamicOffersProps = {
+	tags: string;
+	displayLayout: Layout;
+	productTypes: string[];
+	resultType: ProductTypesResult["resultType"];
+	enableUseCachedOffers: boolean;
+	productTypesDefinition: ProductTypeDefinition[];
+	partnersOverrideDefinition: PartnerOverride[];
+	context: CnfContext;
+} & Omit<
+	GetProductTypesProps,
+	| "context"
+	| "productTypeOrUrl"
+	| "query"
+	| "isDevMode"
+	| "referrer"
+	| "searchAPIToken"
+>;
+
+/**
+ * Retrieves dynamic offers based on the provided parameters.
+ *
+ * @param {GetDynamicOffersProps} params - The parameters for retrieving dynamic offers.
+ * @returns {Promise<{ productTypeDisplayName: string; offers: typeof offers }>} An object containing the product type display name and the offers.
+ */
+export const getDynamicOffers = async ({
+	tags,
+	displayLayout,
+	defaultProductType,
+	productTypes,
+	resultType,
+	enableUseCachedOffers,
+	productTypesDefinition,
+	partnersOverrideDefinition,
+	context,
+}: Omit<GetDynamicOffersProps, "isDev">) => {
+	// Get the initial offers
+	const initialOffersData = await getOffersByProductTypes({
+		enableUseCachedOffers,
+		productTypes,
+		tags,
+		context,
+	});
+
+	// If no initial offers are returned, get offers for the default product type
+	// if initial offers are returned, return them
+	const offersData = isEmpty(initialOffersData?.offers)
+		? await getOffersByProductTypes({
+				enableUseCachedOffers,
+				productTypes: [defaultProductType],
+				tags,
+				context,
+			})
+		: initialOffersData;
+
+	const sortedOffers =
+		resultType === "QUERY"
+			? selectDynamicOffers(offersData.offers, productTypes)
+			: sortOffersByRecommendationScore(offersData.offers);
+
+	return {
+		offers: pipe(
+			sortedOffers,
+			formatOfferUrl(productTypesDefinition, partnersOverrideDefinition),
+			addClientTagsToOfferLinks(enableUseCachedOffers, tags),
+			getOffersBasedOnLayout(displayLayout)
+		),
+		isError: offersData.isError,
+		leadUuid: offersData.leadUuid,
+		rateTableUuid: offersData.uuid,
+	};
+};

package/src/services/getProductTypes.ts

@@ -0,0 +1,53 @@
+import { getProductTypesByQuery } from "./getProductTypesByQuery";
+
+export type GetProductTypesProps = {
+	productType?: string;
+	query?: string;
+	defaultProductType: string;
+	searchAPIToken: string;
+	isDev: boolean;
+};
+
+export type ResultType = "STATIC" | "QUERY" | "PRODUCT_TYPE" | "DEFAULT";
+
+export type ProductTypesResult = {
+	productTypes: string[];
+	resultType: ResultType;
+};
+
+const parseProductTypes = (query: string): string[] => {
+	return query.includes(",")
+		? query.split(",").map((productType) => productType.trim())
+		: [query];
+};
+
+/**
+ * Get the product types
+ * @param props - The properties to get the product types
+ * @returns The product types
+ */
+export const getProductTypes = async ({
+	productType,
+	defaultProductType,
+	query,
+	searchAPIToken,
+	isDev,
+}: GetProductTypesProps): Promise<ProductTypesResult> => {
+	if (query && query.trim().length > 0) {
+		const productTypes = await getProductTypesByQuery({
+			query,
+			searchAPIToken,
+			isDev,
+		});
+
+		return { productTypes, resultType: "QUERY" };
+	}
+
+	// TODO: Check if need to add support for productType as enf app
+	if (productType && productType.trim().length > 0) {
+		const productTypes = await parseProductTypes(productType);
+		return { productTypes, resultType: "PRODUCT_TYPE" };
+	}
+
+	return { productTypes: [defaultProductType], resultType: "DEFAULT" };
+};

package/src/services/getProductTypesByQuery.ts

@@ -0,0 +1,53 @@
+import { pipe } from "effect";
+import { orderProductTypesByRank } from "../../capabilities/core/src/domain/third-party-search";
+import { getEwsSearchApiBaseUrl } from "../apiEnvironment";
+
+type GetProductTypesByQueryProps = {
+	query: string;
+	searchAPIToken: string;
+	isDev: boolean;
+};
+
+/**
+ * Get product types by query
+ * @param query {string} - The query to get the product types for
+ * @param context The context to get the product types from
+ * @returns {Promise<string[]>} The product types
+ *
+ * @example
+ * ```ts
+ * const productTypes = await getProductTypesByQuery('best credit cards', {
+ *   cnfEnv: {
+ *     THIRD_PARTY_SEARCH_API_URL: 'https://api.third-party-search.com',
+ *     THIRD_PARTY_SEARCH_API_TOKEN: 'your-token',
+ *   },
+ *   thirdPartySearchApiClient: makeThirdPartySearchApiClient,
+ * })
+ * // productTypes = ['credit-card', 'loan', 'insurance']
+ * or
+ * // productTypes = []
+ * ```
+ */
+
+export const getProductTypesByQuery = async ({
+	query,
+	searchAPIToken,
+	isDev,
+}: GetProductTypesByQueryProps) => {
+	const url = `${getEwsSearchApiBaseUrl(isDev)}/search/product-types?query=${encodeURIComponent(query)}`;
+	const headers = {
+		Authorization: `Bearer ${searchAPIToken}`,
+	};
+	try {
+		const response = await fetch(url, { headers });
+		if (!response.ok) {
+			throw new Error();
+		}
+		const productTypes = await response.json();
+
+		return pipe(productTypes, orderProductTypesByRank);
+	} catch (error) {
+		console.error("Error fetching ProductTypesByQuery", JSON.stringify(error));
+		return [];
+	}
+};

package/src/utils/addClientTagsToOfferLinks.ts

@@ -0,0 +1,22 @@
+import type { BaseOffer } from "../../capabilities/offer-catalog/src";
+
+/**
+ * Add client tags to offer links
+ * @param enableUseCachedOffers - Whether to use cached offers
+ * @param clientTags - The client tags
+ * @returns The offers with the client tags added to the links
+ */
+export const addClientTagsToOfferLinks =
+	(enableUseCachedOffers: boolean, clientTags: string) =>
+	(offers: BaseOffer[]): BaseOffer[] => {
+		if (!enableUseCachedOffers) {
+			return offers;
+		}
+
+		return offers.map((offer) => {
+			return {
+				...offer,
+				url: `${offer.url}?${clientTags}`,
+			};
+		});
+	};

package/src/utils/formatOfferUrl.ts

@@ -0,0 +1,32 @@
+import {
+	getOfferUrl,
+	type BaseOffer,
+	type PartnerOverride,
+	type ProductTypeDefinition,
+} from "../../capabilities/offer-catalog/src";
+
+/**
+ * Format the offer URL
+ * @param offers - The offers to format if needed
+ * @returns The offers with the formatted URL
+ */
+export const formatOfferUrl =
+	(
+		productTypesDefinition: ProductTypeDefinition[],
+		partnersOverrideDefinition: PartnerOverride[]
+	) =>
+	(offers: BaseOffer[]) => {
+		return offers.map((offer) => {
+			const { url, overrideUrl } = getOfferUrl({
+				offer,
+				productTypesDefinition,
+				partnersOverrideDefinition,
+			});
+
+			return {
+				...offer,
+				url,
+				overrideUrl,
+			};
+		});
+	};

package/src/utils/getDefaultPaletteColor.ts

@@ -0,0 +1,15 @@
+import type { Colors } from "../components/Button";
+
+export const getDefaultPaletteColor = (colorKey: Colors): string => {
+	const defaultColors: Partial<Record<Colors, string>> = {
+		positive: "#00E5C4",
+		// promotional: "#FFD700",
+		// generation: "#4CAF50",
+		// colorScheme: "#9E9E9E",
+		// critical: "#FF0000",
+		// highlight: "#FFA500",
+		// neutral: "#808080",
+	};
+
+	return defaultColors[colorKey] ?? "#000000"; // subject to change
+};

package/src/utils/getDefaultProductType.ts

@@ -0,0 +1,4 @@
+import type { CnfContext } from "../../capabilities/core/src/system/cnfContext/CnfContext";
+
+export const getDefaultProductType = (context: CnfContext) =>
+	context.configuration.configuration.defaultProductTypeSlug;

package/src/utils/getEnableUseCachedOffers.ts

@@ -0,0 +1,13 @@
+import type { CnfContext } from "../../capabilities/core/src/system/cnfContext/CnfContext";
+
+/**
+ * Get enabled cache offers request
+ *
+ * @param {DynamicOffersContext} cnfContext - The context object
+ * @returns {boolean} - The enabled cache offers request
+ *
+ * @description
+ * This function is used to get the enabled cache offers request from payload cms configuration
+ */
+export const getEnableUseCachedOffers = (context: CnfContext) =>
+	context.configuration.configuration?.enableUseCachedOffers;

package/src/utils/getOffersBasedOnLayout.ts

@@ -0,0 +1,51 @@
+import { pipe } from "effect";
+import type { Layout } from "./layouts";
+import { sortOffersByRecommendationScore } from "./sortOffersByRecommendationScore";
+import type { BaseOffer } from "../../capabilities/offer-catalog/src";
+
+const MAX_OFFERS_TO_DISPLAY = 3;
+
+/**
+ * Sorts the offers based on the layout.
+ *
+ * @param offers - The offers to sort.
+ * @returns The sorted offers.
+ */
+export const sortFixedOffers = (offers: BaseOffer[]): BaseOffer[] => {
+	const resultOffers = Array.from(
+		{
+			length:
+				offers.length >= MAX_OFFERS_TO_DISPLAY
+					? MAX_OFFERS_TO_DISPLAY
+					: offers.length,
+		},
+		(_, index) => offers[index % offers.length]
+	).filter((offer): offer is BaseOffer => offer !== undefined);
+
+	return resultOffers;
+};
+
+/**
+ * Gets the offers based on the layout.
+ *
+ * @param layout - The layout to get the offers for.
+ * @param offers - The offers to get.
+ * @returns The offers.
+ */
+export const getOffersByLayout = (layout: Layout) => (offers: BaseOffer[]) => {
+	return layout === "carousel"
+		? sortOffersByRecommendationScore(offers)
+		: sortFixedOffers(offers);
+};
+
+/**
+ * Gets the offers based on the layout.
+ *
+ * @param layout - The layout to get the offers for.
+ * @param offers - The offers to get.
+ * @returns The offers.
+ */
+export const getOffersBasedOnLayout =
+	(layout: Layout) => (offers: BaseOffer[]) => {
+		return pipe(offers, getOffersByLayout(layout));
+	};

package/src/utils/getOffersByProductTypes.ts

@@ -0,0 +1,36 @@
+import type { CnfContext } from "../../capabilities/core/src/system/cnfContext/CnfContext";
+import {
+	getCachedOffersByProductTypes,
+	getOffersForProductTypes,
+} from "../../capabilities/offer-catalog/src/api/offerCatalogApi";
+import { parseClientTags } from "../../capabilities/offer-catalog/src/utils/contextUtil";
+/**
+ * Retrieves offers by product types.
+ *
+ * @param {Object} params - The parameters for retrieving offers by product types.
+ * @param {boolean} params.enableUseCachedOffers - Indicates if the offers should be retrieved from the cache.
+ * @param {string[]} params.productTypes - The product types to retrieve offers for.
+ * @param {string} params.tags - The tags to use for retrieving offers.
+ * @returns {Promise<OffersData>} A promise that resolves to an array of offers or undefined if no offers are found.
+ */
+export const getOffersByProductTypes = async ({
+	enableUseCachedOffers,
+	productTypes,
+	tags,
+	context,
+}: {
+	enableUseCachedOffers: boolean;
+	productTypes: string[];
+	tags: string;
+	context: CnfContext;
+}) => {
+	// TODO it should be just enableUseCachedOffers and not !enableUseCachedOffers
+	if (enableUseCachedOffers) {
+		return await getCachedOffersByProductTypes(context)(productTypes);
+	}
+
+	return await getOffersForProductTypes(context)(
+		productTypes,
+		parseClientTags(tags)
+	);
+};

package/src/utils/getProductTypesDefinition.ts

@@ -0,0 +1,13 @@
+import type { CnfContext } from "../../capabilities/core/src/system/cnfContext/CnfContext";
+
+export const getProductTypesDefinition = (context: CnfContext) => {
+	const offersConfig = context.configuration.configuration;
+
+	const productTypesDefinition = offersConfig?.productTypesDefinition;
+	const partnersOverrideDefinition = offersConfig?.partnersOverrideDefinition;
+
+	return {
+		productTypesDefinition,
+		partnersOverrideDefinition,
+	};
+};

package/src/utils/index.ts

@@ -0,0 +1,10 @@
+export * from "./addClientTagsToOfferLinks";
+export * from "./getDefaultProductType";
+export * from "./getOffersByProductTypes";
+export * from "./getProductTypesDefinition";
+export * from "./layouts";
+export * from "./resolveProductTypes";
+export * from "./selectDynamicOffers";
+export * from "./sortOffersByRecommendationScore";
+export * from "./parseStringProductTypes";
+export * from "./getEnableUseCachedOffers";

package/src/utils/layouts.ts

@@ -0,0 +1,22 @@
+export const layouts = {
+	carousel: "carousel",
+	fixed: "fixed",
+} as const;
+
+export type Layout = keyof typeof layouts;
+
+/**
+ * Get layout based on the provided layout
+ * @param layout {string | null} layout
+ * @returns {Layout} layout or default layout
+ *
+ * @example
+ * getLayout('fixed') // 'fixed'
+ * getLayout('invalidLayout') // 'carousel'
+ * getLayout(null) // 'carousel'
+ * getLayout('') // 'carousel'
+ * getLayout('carousel') // 'carousel'
+ */
+export const getLayout = (layout?: string): Layout => {
+	return layouts[layout as Layout] ?? layouts.carousel;
+};

package/src/utils/parseStringProductTypes.ts

@@ -0,0 +1,7 @@
+export const parseStringProductTypes = (productTypes?: string) => {
+	if (!productTypes || productTypes.length === 0) {
+		return [];
+	}
+
+	return productTypes.split(",").map((productType) => productType.trim());
+};

package/src/utils/resolveProductTypes.ts

@@ -0,0 +1,18 @@
+import { getProductTypes, type ResultType } from "../services/getProductTypes";
+
+type ResolveProductTypesProps = {
+	productType?: string;
+	query?: string;
+	defaultProductType: string;
+	searchAPIToken: string;
+	isDev: boolean;
+};
+
+export const resolveProductTypes = async (
+	props: ResolveProductTypesProps
+): Promise<{
+	productTypes: string[];
+	resultType: ResultType;
+}> => {
+	return await getProductTypes(props);
+};

package/src/utils/selectDynamicOffers.ts

@@ -0,0 +1,18 @@
+import type { BaseOffer } from "../../capabilities/offer-catalog/src";
+import { sortOffersByRecommendationScore } from "./sortOffersByRecommendationScore";
+
+
+export const selectDynamicOffers = (
+	offers: BaseOffer[],
+	productTypes: string[]
+) => {
+	const resultOffers = productTypes
+		.flatMap((productType) =>
+			sortOffersByRecommendationScore(
+				offers.filter((offer) => offer.productType === productType)
+			)
+		)
+		.slice(0, 10) as BaseOffer[];
+
+	return resultOffers;
+};

package/src/utils/sortOffersByRecommendationScore.ts

@@ -0,0 +1,6 @@
+import { sort } from "radash";
+import type { BaseOffer } from "../../capabilities/offer-catalog/src";
+
+export const sortOffersByRecommendationScore = (offers: BaseOffer[]) => {
+	return sort(offers, (offer) => offer.recommendationScore, true);
+};

package/src/version.ts

@@ -0,0 +1,2 @@
+import packageJson from "../package.json";
+export const VERSION = packageJson.version;