@moneylion/react-native-offer-carousel 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@moneylion/react-native-offer-carousel",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"description": "React Native components for the Engine by MoneyLion Mobile SDK",
 	"main": "lib/commonjs/index",
 	"module": "lib/module/index",

package/src/capabilities/configuration/src/brands/checkVisualEligibility.ts

@@ -0,0 +1,29 @@
+import { get } from "radash";
+import { enhanceType, type Brand } from "./types";
+import { match, P } from "ts-pattern";
+
+/**
+ * A UI centric concept that prioritizes brands for visual use, both by the data available and the preferences of the brand.
+ */
+export type VisualBrandKind = "primary" | "secondary" | "none";
+
+/**
+ * Determines the highest visual eligibility a Brand supports.
+ * Used to rank a primary eligible brand highest if no brand prefers primary, such as a licensed brand
+ * @param brand
+ */
+export const checkVisualBrandEligibility = (brand: Brand) =>
+	match([enhanceType(brand), get(brand, "allowedMarks"), brand?.isLicensed])
+		.returnType<VisualBrandKind>()
+		.with(
+			[P._, P._, true],
+			["business", { logo: true, name: true }, P.any],
+			["product", { logo: true, name: true }, P.any],
+			() => "primary"
+		)
+		.with(
+			["individual", P._, P.any],
+			["business", { name: true, logo: false }, P.any],
+			() => "secondary"
+		)
+		.otherwise(() => "none");

package/src/capabilities/configuration/src/brands/createDerivedBrands.ts

@@ -0,0 +1,39 @@
+import { isObject, sift } from "radash";
+import type { Brand } from "../../../../../builder";
+import { P, match } from "ts-pattern";
+import { enhanceType } from "./types";
+import { checkVisualBrandEligibility } from "./checkVisualEligibility";
+
+/**
+ * Extracts and normalizes a brand into -
+ * LicensedBrand - The brand to be used for terms, legal and other compliance needs
+ * VisualBrands - The brands to be shown to the user
+ * @param brand
+ */
+export const createDerivedBrands = (brand: Brand) => {
+	// Determine the licensed brand for this brand, keeping in mind that this brand may be the licensed brand
+	const licensedBrand = match([
+		enhanceType(brand),
+		brand?.isLicensed || brand?.licensedBrand,
+	])
+		// Ensure we get back a brand at the end
+		.returnType<Brand>()
+		// If the type is licensed, return this brand
+		.with(["licensed", P._], () => brand)
+		// If the type is not licensed, but there is a cobrand setup, use that to get the licensed brand
+		.with(
+			[P.not("licensed"), P.select("licensedBrandObj")],
+			({ licensedBrandObj }) => {
+				if (isObject(licensedBrandObj)) return licensedBrandObj;
+				// Throw if no licensed brand is able to be found
+				throw new Error("Missing Licensed Brand");
+			}
+		)
+		.otherwise(() => {
+			throw new Error("Missing Licensed Brand");
+		});
+
+	// Determine the set of visual brands which should be displayed on the page
+	const brandCanBeShown = checkVisualBrandEligibility(brand) !== "none";
+	return Array.from(new Set(sift([licensedBrand, brandCanBeShown && brand])));
+};

package/src/capabilities/configuration/src/brands/index.ts

@@ -0,0 +1,2 @@
+export { enhanceType } from "./types";
+export { checkVisualBrandEligibility } from "./checkVisualEligibility";

package/src/capabilities/configuration/src/brands/types.ts

@@ -0,0 +1,8 @@
+import { isObject } from "radash";
+import type { Brand } from "../../../../../builder";
+
+export const enhanceType = (brand: Brand) => {
+	if (isObject(brand)) return brand?.isLicensed ? "licensed" : brand.type;
+	return undefined;
+};
+export type { Brand };

package/src/capabilities/core/src/domain/third-party-search/index.ts

@@ -0,0 +1 @@
+export * from "./orderProductTypesByRankUtils";

package/src/capabilities/core/src/domain/third-party-search/orderProductTypesByRankUtils.ts

@@ -0,0 +1,33 @@
+/**
+ * Orders product types by rank.
+ *
+ * @param productTypes {Record<string, number>} - The product types to order.
+ * @returns {string[]} The product types ordered by rank.
+ *
+ * @example
+ * ```ts
+ * const productTypes = {
+ *   'credit-card': 1,
+ *   'loan': 2,
+ *   'insurance': 3,
+ * }
+ * const orderedProductTypes = orderProductTypesByRank(productTypes)
+ * // orderedProductTypes = ['insurance', 'loan', 'credit-card']
+ * ```
+ */
+export const orderProductTypesByRank = (
+	productTypes: Record<string, number>
+) => {
+	const productTypesWithRank = Object.entries(productTypes).map(
+		([productType, count]) => ({
+			productType,
+			rank: count as number,
+		})
+	);
+
+	const sortedProductTypes = productTypesWithRank.sort(
+		(a, b) => b.rank - a.rank
+	);
+
+	return sortedProductTypes.map((pt) => pt.productType);
+};

package/src/capabilities/core/src/index.ts

@@ -0,0 +1 @@
+export * from "./system/cnfContext/schemas";

package/src/capabilities/core/src/system/cnfContext/CnfContext.ts

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+import {
+	App,
+	Brand,
+	CnfRequest,
+	Configuration,
+	Signals,
+	Subaccount,
+} from "./schemas";
+
+export const CnfContext = Schema.Struct({
+	app: App,
+	brand: Brand,
+	configuration: Configuration,
+	request: CnfRequest,
+	signals: Signals,
+	subaccount: Subaccount,
+	isDev: Schema.Boolean,
+});
+
+export type CnfContext = Schema.Schema.Type<typeof CnfContext>;

package/src/capabilities/core/src/system/cnfContext/schemas/App.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+
+export type App = Schema.Schema.Type<typeof App>;
+export const App = Schema.Struct({
+	id: Schema.UUID,
+	name: Schema.String,
+	registry: Schema.String,
+	repository: Schema.String,
+	syncStatus: Schema.String,
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	syncTimestamp: Schema.String,
+});

package/src/capabilities/core/src/system/cnfContext/schemas/Brand.ts

@@ -0,0 +1,119 @@
+import { Schema } from "effect";
+
+export type Palette = Schema.Schema.Type<typeof Palette>;
+const Palette = Schema.Struct({
+	promotional: Schema.optional(Schema.String),
+	generation: Schema.optional(Schema.Literal("generate", "provided")),
+	colorScheme: Schema.optional(Schema.Literal("balanced", "light", "dark")),
+	positive: Schema.optional(Schema.String),
+	critical: Schema.optional(Schema.String),
+	highlight: Schema.optional(Schema.String),
+	neutral: Schema.optional(Schema.String),
+});
+
+export type Links = Schema.Schema.Type<typeof Links>;
+const Links = Schema.Struct({
+	home: Schema.optional(Schema.String),
+	terms: Schema.optional(Schema.String),
+	support: Schema.optional(Schema.String),
+	privacy: Schema.optional(Schema.String),
+});
+
+export type AiInference = Schema.Schema.Type<typeof AiInference>;
+const AiInference = Schema.Struct({
+	status: Schema.String,
+	error: Schema.optional(Schema.String),
+});
+
+export type Media = Schema.Schema.Type<typeof Media>;
+const Media = Schema.Struct({
+	id: Schema.String,
+	autoCrop: Schema.Boolean,
+	prefix: Schema.optional(Schema.String),
+	alt: Schema.optional(Schema.String),
+	url: Schema.optional(Schema.String),
+	filename: Schema.optional(Schema.String),
+	mimeType: Schema.optional(Schema.String),
+	filesize: Schema.optional(Schema.Number),
+	width: Schema.optional(Schema.Number),
+	height: Schema.optional(Schema.Number),
+	createdAt: Schema.optional(Schema.String),
+	updatedAt: Schema.optional(Schema.String),
+	aiInference: Schema.optional(AiInference),
+});
+
+export type Logos = Schema.Schema.Type<typeof Logos>;
+const Logos = Schema.Struct({
+	horizontal: Schema.optional(Media),
+	icon: Schema.optional(Schema.NullOr(Media)),
+});
+
+export type FontFamily = Schema.Schema.Type<typeof FontFamily>;
+const FontFamily = Schema.Literal(
+	"nunito",
+	"lato",
+	"sourceSans3",
+	"openSans",
+	"roboto",
+	"arimo",
+	"montserrat"
+);
+
+export type Font = Schema.Schema.Type<typeof Font>;
+const Font = Schema.Struct({
+	family: Schema.optional(FontFamily),
+});
+
+export type AllowedMarks = Schema.Schema.Type<typeof AllowedMarks>;
+const AllowedMarks = Schema.Struct({
+	logo: Schema.Boolean,
+	name: Schema.Boolean,
+});
+
+export type CtaRoundness = Schema.Schema.Type<typeof CtaRoundness>;
+const CtaRoundness = Schema.Struct({
+	small: Schema.optional(Schema.Number),
+	medium: Schema.optional(Schema.Number),
+	large: Schema.optional(Schema.Number),
+});
+
+type BrandFields = Schema.Schema.Type<typeof BrandFields>;
+const BrandFields = Schema.Struct({
+	id: Schema.String,
+	domain: Schema.String,
+	displayName: Schema.String,
+	isLicensed: Schema.optional(Schema.Boolean),
+	hideLicensedLogo: Schema.optional(Schema.Boolean),
+	palette: Schema.optional(Palette),
+	links: Schema.optional(Links),
+	logos: Schema.optional(Logos),
+	font: Schema.optional(Font),
+	type: Schema.optional(Schema.Literal("business", "product", "individual")),
+	allowedMarks: AllowedMarks,
+	ctaRoundness: Schema.optional(CtaRoundness),
+	createdAt: Schema.optional(Schema.String),
+	updatedAt: Schema.optional(Schema.String),
+});
+
+export type Brand = BrandFields & {
+	licensedBrand?: Brand | null;
+};
+
+export const Brand = Schema.suspend((): Schema.Schema<Brand> => {
+	const withDepth = (
+		depth: number
+	): Schema.Schema<Brand> | Schema.Schema<BrandFields> => {
+		if (depth > 2) {
+			return BrandFields; // We don't want infinite recursion of licensedBrand field
+		}
+
+		return Schema.Struct({
+			...BrandFields.fields,
+			licensedBrand: Schema.optional(
+				Schema.NullOr(Schema.suspend(() => withDepth(depth + 1)))
+			),
+		});
+	};
+
+	return withDepth(0); // Start with depth 0
+});

package/src/capabilities/core/src/system/cnfContext/schemas/Configuration.ts

@@ -0,0 +1,49 @@
+import { Schema } from "effect";
+
+const ProductTypesDefinition = Schema.Struct({
+	id: Schema.String,
+	partnerPageUrl: Schema.String,
+	productTypeSlug: Schema.String,
+});
+
+const PartnersOverrideDefinition = Schema.Struct({
+	id: Schema.String,
+	overrideUrl: Schema.String,
+	financialInstitutionUuid: Schema.String,
+});
+
+export const DynamicOffersConfigurationSchema = Schema.Struct({
+	hideFooter: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+	enableUseCachedOffers: Schema.optionalWith(Schema.Boolean, {
+		default: () => false,
+	}),
+	defaultProductTypeSlug: Schema.optionalWith(Schema.String, {
+		default: () => "EarnedWageAccess",
+	}),
+	productTypesDefinition: Schema.optionalWith(
+		Schema.Array(ProductTypesDefinition),
+		{
+			default: () => [],
+		}
+	),
+	partnersOverrideDefinition: Schema.optionalWith(
+		Schema.Array(PartnersOverrideDefinition),
+		{ default: () => [] }
+	),
+});
+
+export type DynamicOffersConfigurationSchema = Schema.Schema.Type<
+	typeof DynamicOffersConfigurationSchema
+>;
+
+export const Configuration = Schema.Struct({
+	app: Schema.Union(
+		Schema.String,
+		Schema.Struct({
+			name: Schema.String,
+		})
+	),
+	configuration: DynamicOffersConfigurationSchema,
+});
+
+export type Configuration = Schema.Schema.Type<typeof Configuration>;

package/src/capabilities/core/src/system/cnfContext/schemas/Request.ts

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+
+export type CnfRequest = Schema.Schema.Type<typeof CnfRequest>;
+export const CnfRequest = Schema.Struct({
+	referer: Schema.optional(Schema.String),
+	channel: Schema.optional(Schema.String),
+	zone: Schema.optional(Schema.String),
+	cnfAppBaseUrl: Schema.optionalWith(Schema.String, {
+		default: () => "http://localhost:3000",
+	}),
+	path: Schema.optional(Schema.String),
+	pathname: Schema.optional(Schema.String),
+	query: Schema.optional(Schema.String),
+	searchParams: Schema.Struct({}),
+	host: Schema.optional(Schema.String),
+});

package/src/capabilities/core/src/system/cnfContext/schemas/Session.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+
+export type SessionId = Schema.Schema.Type<typeof SessionId>;
+export const SessionId = Schema.UUID.pipe(Schema.brand("SessionId"));
+
+export type Session = Schema.Schema.Type<typeof Session>;
+export const Session = Schema.Struct({
+	id: SessionId,
+});

package/src/capabilities/core/src/system/cnfContext/schemas/Signals.ts

@@ -0,0 +1,47 @@
+import { Schema } from "effect";
+
+export type PartnerSignals = Schema.Schema.Type<typeof PartnerSignals>;
+export const PartnerSignals = Schema.Struct({
+	clientTags: Schema.Struct({}, { key: Schema.String, value: Schema.String }),
+});
+
+export type DeviceId = Schema.Schema.Type<typeof DeviceId>;
+export const DeviceId = Schema.UUID;
+
+export type DeviceSignals = Schema.Schema.Type<typeof DeviceSignals>;
+const DeviceSignals = Schema.Struct({
+	id: DeviceId,
+	ipAddress: Schema.optional(Schema.String),
+	os: Schema.optional(Schema.String),
+	isMobile: Schema.optional(Schema.Boolean),
+	country: Schema.optional(Schema.String),
+	state: Schema.optional(
+		Schema.Struct({
+			name: Schema.optional(Schema.String),
+			code: Schema.optional(Schema.String),
+		})
+	),
+	postalCode: Schema.String,
+	city: Schema.String,
+	fingerprintId: Schema.optional(Schema.String),
+	userAgent: Schema.optional(Schema.String),
+});
+
+export type LeadUuid = Schema.Schema.Type<typeof LeadUuid>;
+export const LeadUuid = Schema.UUID;
+
+export type LeadSignals = Schema.Schema.Type<typeof LeadSignals>;
+export const LeadSignals = Schema.Struct({
+	uuid: LeadUuid,
+});
+
+export type ReferralSignals = Schema.Schema.Type<typeof ReferralSignals>;
+export const ReferralSignals = Schema.Struct({});
+
+export type Signals = Schema.Schema.Type<typeof Signals>;
+export const Signals = Schema.Struct({
+	partnerSignals: PartnerSignals,
+	deviceSignals: DeviceSignals,
+	lead: LeadSignals,
+	referral: ReferralSignals,
+});

package/src/capabilities/core/src/system/cnfContext/schemas/Subaccount.ts

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+
+const EmptyString = Schema.Literal("");
+const NullOrEmptyString = <S extends Schema.Schema.Any>(schema: S) =>
+	Schema.Union(Schema.Null, EmptyString, schema);
+
+const Tag = Schema.Struct({
+	id: Schema.String,
+	key: Schema.String,
+	value: Schema.String,
+});
+
+export const Subaccount = Schema.Struct({
+	id: Schema.UUID,
+	publicToken: Schema.String,
+	name: Schema.String,
+	companyUuid: Schema.String,
+	subaccount: Schema.NullOr(Schema.Number),
+	supplySubaccountUuid: Schema.UUID.pipe(NullOrEmptyString, Schema.optional),
+	tags: Schema.Array(Tag),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+});
+
+export type Subaccount = Schema.Schema.Type<typeof Subaccount>;

package/src/capabilities/core/src/system/cnfContext/schemas/index.ts

@@ -0,0 +1,7 @@
+export * from "./App";
+export * from "./Brand";
+export * from "./Configuration";
+export * from "./Request";
+export * from "./Session";
+export * from "./Signals";
+export * from "./Subaccount";

package/src/capabilities/offer-catalog/src/api/offerCatalogApi.ts

@@ -0,0 +1,171 @@
+import { isEmpty } from "radash";
+import type { CnfContext } from "../../../core/src/system/cnfContext/CnfContext";
+import type { OffersData } from "../types/offerCatalogSchema";
+import {
+	getIsDevEnvironment,
+	getLeadUUID,
+	getStateCode,
+	getSubAccountUUID,
+	getSubaccountToken,
+} from "../utils/contextUtil";
+import errorUtil from "../utils/errorUtil";
+import type { State } from "../../../offers/pipeline/src/sources/ratetables/types";
+import { withDeviceSignals } from "../../../offers/pipeline/src/sources/ratetables/withDeviceSignals";
+import { getOfferCatalogApiBaseUrl } from "../../../../apiEnvironment";
+
+export const getCachedOffersByProductTypes =
+	(context: CnfContext) => async (productTypes: string[]) => {
+		// const cachedOffersByProductTypesLogger = pinoRootLogger.child({
+		// 	name: "cachedOffersByProductTypesLogger",
+		// });
+
+		try {
+			const subAccountUuid = getSubAccountUUID(context);
+			const isDev = getIsDevEnvironment(context);
+
+			const url = new URL(
+				`${getOfferCatalogApiBaseUrl(isDev)}/leads/public/channelOffers`
+			);
+
+			url.searchParams.append("productType", productTypes.join(","));
+			if (subAccountUuid) {
+				url.searchParams.append("channelUuid", subAccountUuid);
+			}
+
+			// TODO find a way to add the revalidate: 3600 kind of logic here
+			const response = await fetch(url.toString(), {
+				method: "GET",
+				headers: {
+					"Content-Type": "application/json",
+				},
+			});
+
+			const logFormat = {
+				status: response.status,
+				statusText: response.statusText,
+				url: response.url,
+			};
+
+			if (!response.ok) {
+				const errorMessage = errorUtil.getErrorMessageForResponseStatus(
+					response.status,
+					response.statusText
+				);
+				console.error(logFormat, errorMessage);
+				throw new Error(errorMessage);
+			}
+
+			const offersData: OffersData = await response.json();
+
+			if (isEmpty(offersData.offers)) {
+				const errorMessage =
+					errorUtil.getErrorForOffersFromProductTypes("NO_OFFERS");
+				console.error(logFormat, errorMessage);
+				throw new Error(errorMessage);
+			}
+			return offersData;
+		} catch (error) {
+			const errorMessage =
+				errorUtil.getErrorForOffersFromProductTypes("DEFAULT");
+			console.error(error, errorMessage);
+
+			return {
+				isError: true,
+				leadUuid: "",
+				offers: [],
+				uuid: "",
+			};
+		}
+	};
+
+export const getOffersForProductTypes =
+	(context: CnfContext) =>
+	async (
+		productTypes: string[],
+		customClientTags?: Record<string, string[]>
+	): Promise<OffersData> => {
+		// const offersFromProductTypesLogger = pinoRootLogger.child({
+		// 	name: "offersFromProductTypesLogger",
+		// });
+
+		try {
+			const token = getSubaccountToken(context);
+			const leadUuid = getLeadUUID(context);
+			const isDev = getIsDevEnvironment(context);
+
+			let fields = {
+				productTypes,
+				clientTags: customClientTags,
+			};
+
+			try {
+				const stateCode = getStateCode(context);
+				// TODO: Refactor to not use this withDeviceSignals
+				fields = withDeviceSignals(context, {
+					productTypes,
+					clientTags: customClientTags,
+					personalInformation: { state: stateCode as State },
+				});
+			} catch (error) {
+				// handle error if context is not available. This scenario should not occur in production
+				console.error(
+					error,
+					errorUtil.getErrorForOffersFromProductTypes("DEVICE_SIGNALS_ERROR")
+				);
+			}
+
+			const url = `${getOfferCatalogApiBaseUrl(isDev)}/leads/${leadUuid}/offerCatalogRateTables`;
+
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"Authorization": `Bearer ${token}`,
+				},
+				body: JSON.stringify(fields),
+			});
+
+			const body = await response.json();
+
+			const logFormat = {
+				status: response.status,
+				statusText: response.statusText,
+				url: response.url,
+				body,
+				fields,
+			};
+
+			if (!response.ok) {
+				const errorMessage = errorUtil.getErrorMessageForResponseStatus(
+					response.status,
+					response.statusText
+				);
+
+				console.error(logFormat, errorMessage);
+
+				throw new Error(errorMessage);
+			}
+
+			const offersData: OffersData = body;
+
+			if (isEmpty(offersData.offers)) {
+				const errorMessage =
+					errorUtil.getErrorForOffersFromProductTypes("NO_OFFERS");
+				console.error(logFormat, errorMessage);
+				throw new Error(errorMessage);
+			}
+
+			return offersData;
+		} catch (error) {
+			const errorMessage =
+				errorUtil.getErrorForOffersFromProductTypes("DEFAULT");
+			console.error(error, errorMessage);
+
+			return {
+				isError: true,
+				leadUuid: "",
+				offers: [],
+				uuid: "",
+			};
+		}
+	};

package/src/capabilities/offer-catalog/src/index.ts

@@ -0,0 +1,10 @@
+export type * from "./types/offerCatalogSchema";
+export * from "./utils/arrayToMarkdownList";
+export { getOfferUrl } from "./utils/getOfferUrl";
+export { getSubAccountUUID } from "./utils/contextUtil";
+export {
+	formatAmount,
+	formatPercentage,
+	formatStringListWithAnd,
+	formatRange,
+} from "./utils/formatUtils";