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

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";

package/src/capabilities/offer-catalog/src/types/offerCatalogSchema.ts

@@ -0,0 +1,119 @@
+export type BaseOffer = {
+	productVersions: number[];
+	uuid: string;
+	version: number;
+	url: string;
+	financialInstitutionUuid: string;
+	createdAt: string;
+	internalName: string;
+	legalLanguage?: string;
+	unmonetizedUrl: string;
+	recommendationScore: number;
+	productDisplayName: string;
+	productType: string;
+	financialInstitutionImageUrl: string;
+	status: "active" | "inactive" | "pending";
+	updatedAt: string;
+	financialInstitutionDisplayName: string;
+	keywords?: string[];
+	acceptanceRequirements?: string;
+	headline?: string;
+	monetizedUrl?: string;
+	disclaimer?: string;
+	firmness?: string;
+	annualPercentageRateType?: "fixed" | "variable";
+	annualPercentageRateBasisPointsMax?: number;
+	annualPercentageRateBasisPointsMin?: number;
+	amountCentsMax?: number;
+	amountCentsMin?: number;
+	description?: string;
+	descriptionPoints?: string[];
+	monthlyPaymentCentsMin?: number;
+	monthlyPaymentCentsMax?: number;
+	creditBureauReporting?: string[];
+	stateExclusions?: string[];
+	enrollmentFeeBasisPointsMax?: number;
+	enrollmentFeeBasisPointsMin?: number;
+	debtAmountCentsMin?: number;
+	debtAmountCentsMax?: number;
+	monthlyFeeCentsMin?: number;
+	monthlyFeeCentsMax?: number;
+	fastTransferFeeCentsMin?: number;
+	fastTransferFeeCentsMax?: number;
+	fastTransferFeeBasisPointsMin?: number;
+	fastTransferFeeBasisPointsMax?: number;
+	annualAdvisoryFeeBasisPointsMin?: number;
+	annualAdvisoryFeeBasisPointsMax?: number;
+	accountCentsMin?: number;
+	termLengthMonthsMin?: number;
+	termLengthMonthsMax?: number;
+	demandSubAccountUuid?: string;
+	demandSubAccountImageUrl?: string;
+	demandSubAccountDisplayName?: string;
+	outOfNetworkAtmUsageFeeCents?: number;
+	annualPercentageYieldBasisPoints?: number;
+	isMonetized?: boolean;
+	overrideUrl?: string;
+};
+export type DemandPartner = {
+	uuid: string;
+	name: string;
+	description: string;
+	disclaimer: string;
+	supportsPreSelect: boolean;
+	shouldDisplayPreSelect: boolean;
+	supportsPersonalizedOffers: boolean;
+	imageUrl: string;
+	subtextOverride?: string;
+};
+
+export type BasicRateTablePendingResponse = {
+	partner: DemandPartner;
+	offerCatalogProductTypes: string[];
+};
+
+export type ProductTypes =
+	| "CreditBuilderLoan"
+	| "DebtSettlement"
+	| "HomeEquityLineOfCredit"
+	| "RoboInvesting"
+	| "StudentLoanRefinance"
+	| "IncomeOpportunities"
+	| "CashManagementAccount"
+	| "HomeEquityLoan"
+	| "StudentLoan"
+	| "CashAdvance"
+	| "EarnedWageAccess"
+	| "RoboInvesting"
+	| "StudentLoanRefinance"
+	| "StudentLoan"
+	| "AutomobileLoan"
+	| "AutomobileRefinance"
+	| "UnsecuredPersonalLoan"
+	| "SecuredPersonalLoan"
+	| "UnsecuredLineOfCredit"
+	| "OverdraftProtection"
+	| "CreditBuilderSecuredCreditCard"
+	| "CreditBuilderDebitCard"
+	| "RentUtilityBillReporting"
+	| (string & {});
+
+export type OffersData = {
+	isError?: boolean;
+	uuid: string;
+	leadUuid: string;
+	offers: BaseOffer[];
+	pendingResponses?: BasicRateTablePendingResponse[];
+};
+
+export type ProductTypeDefinition = {
+	id: string;
+	partnerPageUrl: string;
+	productTypeSlug: string;
+};
+
+export type PartnerOverride = {
+	id: string;
+	overrideUrl: string;
+	financialInstitutionUuid: string;
+};

package/src/capabilities/offer-catalog/src/utils/arrayToMarkdownList.ts

@@ -0,0 +1,3 @@
+export const arrayToMarkdownList = (arr: string[]) => {
+	return arr?.map((item) => `- ${item}`).join("\n");
+};