@infrab4a/connect 5.3.0-beta.31 → 5.3.0-beta.33

package/index.cjs.js

@@ -157,6 +157,123 @@ class PaymentProviderFactory {
     }
 }
 
+const ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS = 60;
+/**
+ * Lê `shopConfigs.antifraude.enabled`.
+ * - `false` explícito → antifraude desligado
+ * - ausente / erro / inválido → `true` (mantém comportamento histórico)
+ */
+async function isAntifraudEnabled(shopConfigsRepository) {
+    if (!shopConfigsRepository) {
+        return true;
+    }
+    try {
+        const result = await shopConfigsRepository.find({}, { cache: { enabled: true, ttl: ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS } });
+        const enabled = result?.data?.at(0)?.antifraude?.enabled;
+        if (typeof enabled === 'boolean') {
+            return enabled;
+        }
+        return true;
+    }
+    catch (error) {
+        console.warn(JSON.stringify({
+            msg: 'antifraud_enabled_config_load_failed',
+            enabled: true,
+            error: error instanceof Error ? error.message : String(error),
+        }));
+        return true;
+    }
+}
+
+/** Defaults de runtime (week.zip = Infinity). Usados só como fallback no checkout. */
+const DEFAULT_ANTIFRAUD_VOLUME_LIMITS = {
+    enabled: true,
+    source: 'fallback',
+    day: {
+        subscriber: { cpf: 4, email: 4, phone: 4, card: 4, zip: 4 },
+        nonSubscriber: { cpf: 2, email: 2, phone: 2, card: 2, zip: 2 },
+    },
+    week: {
+        subscriber: { cpf: 12, email: 12, phone: 12, card: 12, zip: Infinity },
+        nonSubscriber: { cpf: 7, email: 7, phone: 7, card: 7, zip: Infinity },
+    },
+    blockedAttemptsDay: {
+        subscriber: 7,
+        nonSubscriber: 5,
+    },
+};
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 1 && Number.isInteger(value);
+}
+function normalizeLimitOrders(raw, allowInfiniteZip) {
+    if (!raw)
+        return null;
+    const zip = allowInfiniteZip && (raw.zip === null || raw.zip === undefined || raw.zip === Infinity) ? Infinity : raw.zip;
+    const normalized = {
+        cpf: raw.cpf,
+        email: raw.email,
+        phone: raw.phone,
+        zip: zip,
+        card: raw.card,
+    };
+    for (const key of ['cpf', 'email', 'phone', 'zip', 'card']) {
+        if (key === 'zip' && normalized.zip === Infinity)
+            continue;
+        if (!isPositiveInteger(normalized[key]))
+            return null;
+    }
+    return normalized;
+}
+function cloneFallbackLimits() {
+    return {
+        ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS,
+        day: {
+            subscriber: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.day.subscriber },
+            nonSubscriber: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.day.nonSubscriber },
+        },
+        week: {
+            subscriber: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.week.subscriber },
+            nonSubscriber: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.week.nonSubscriber },
+        },
+        blockedAttemptsDay: { ...DEFAULT_ANTIFRAUD_VOLUME_LIMITS.blockedAttemptsDay },
+        source: 'fallback',
+    };
+}
+/** Config inválida/ausente → fallback (comportamento histórico). */
+function resolveAntifraudVolumeLimits(antifraude) {
+    if (!antifraude || typeof antifraude.enabled !== 'boolean') {
+        return cloneFallbackLimits();
+    }
+    const daySubscriber = normalizeLimitOrders(antifraude.day?.subscriber, false);
+    const dayNonSubscriber = normalizeLimitOrders(antifraude.day?.nonSubscriber, false);
+    const weekSubscriber = normalizeLimitOrders(antifraude.week?.subscriber, true);
+    const weekNonSubscriber = normalizeLimitOrders(antifraude.week?.nonSubscriber, true);
+    const blocked = antifraude.blockedAttemptsDay;
+    if (!daySubscriber ||
+        !dayNonSubscriber ||
+        !weekSubscriber ||
+        !weekNonSubscriber ||
+        !blocked ||
+        !isPositiveInteger(blocked.subscriber) ||
+        !isPositiveInteger(blocked.nonSubscriber)) {
+        // Kill-switch explícito prevalece mesmo com payload inválido.
+        if (antifraude.enabled === false) {
+            return { ...cloneFallbackLimits(), enabled: false, source: 'fallback' };
+        }
+        return cloneFallbackLimits();
+    }
+    return {
+        enabled: antifraude.enabled,
+        source: 'config',
+        day: { subscriber: daySubscriber, nonSubscriber: dayNonSubscriber },
+        week: { subscriber: weekSubscriber, nonSubscriber: weekNonSubscriber },
+        blockedAttemptsDay: {
+            subscriber: blocked.subscriber,
+            nonSubscriber: blocked.nonSubscriber,
+        },
+    };
+}
+
 const registry = new Map();
 function registerClass(name, classConstructor) {
     registry.set(name, classConstructor);
@@ -1038,6 +1155,12 @@ class CampaignHashtag extends BaseModel {
     }
 }
 
+class CampaignHashtagPosts extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
 class BeautyProfile extends BaseModel {
     toPlain() {
         const plain = super.toPlain();
@@ -1757,6 +1880,27 @@ class OrderBlocked extends BaseModel {
     }
 }
 
+/**
+ * Queue document for millenium shop-order send/retry.
+ * Firestore collection remains `transId` (see PendingOrderFirestoreRepository).
+ */
+class PendingOrder extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+    get firstErrorMessage() {
+        if (!Array.isArray(this.errorMessage) || this.errorMessage.length === 0) {
+            return null;
+        }
+        const first = this.errorMessage[0];
+        if (typeof first !== 'string') {
+            return null;
+        }
+        const trimmed = first.trim();
+        return trimmed ? trimmed : null;
+    }
+}
+
 class ShoppingRecurrence extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -1906,12 +2050,23 @@ class StockOutError extends BusinessError {
     }
 }
 
+/* eslint-disable no-console */
 class AntifraudBankSlipService {
-    constructor(orderBlockedRepository) {
+    constructor(orderBlockedRepository, shopConfigsRepository) {
         this.orderBlockedRepository = orderBlockedRepository;
+        this.shopConfigsRepository = shopConfigsRepository;
         this.MAX_ORDER_VALUE = 5000;
     }
     async validate(checkout) {
+        const enabled = await isAntifraudEnabled(this.shopConfigsRepository);
+        if (!enabled) {
+            console.info(JSON.stringify({
+                msg: 'antifraud_bankslip_skipped',
+                enabled: false,
+                checkoutId: checkout.id,
+            }));
+            return true;
+        }
         if (checkout.totalPrice && checkout.totalPrice > this.MAX_ORDER_VALUE && !checkout.user?.isSubscriber) {
             await this.orderBlockedRepository.createBlockedOrderOrPayment({
                 checkout,
@@ -1933,62 +2088,67 @@ class AntifraudBankSlipService {
     }
 }
 
+/* eslint-disable max-params */
 class AntifraudCardService {
-    constructor(orderRepository, orderBlockedRepository) {
+    constructor(orderRepository, orderBlockedRepository, shopConfigsRepository) {
         this.orderRepository = orderRepository;
         this.orderBlockedRepository = orderBlockedRepository;
-        this.LIMIT_ORDERS_DAY = null;
-        this.LIMIT_ORDERS_WEEK = null;
+        this.shopConfigsRepository = shopConfigsRepository;
     }
     async validate(checkout, card) {
-        this.setLimitsByUserType(checkout.user.isSubscriber);
-        await this.validateBlockedOrderAttempts(checkout, card);
-        await this.validateDayAndWeekOrderLimits(checkout, card);
+        // Limites locais por request — evita race em provider Nest singleton entre awaits.
+        const resolved = await this.loadResolvedLimits();
+        const isSubscriber = !!checkout.user?.isSubscriber;
+        const dayLimits = isSubscriber ? resolved.day.subscriber : resolved.day.nonSubscriber;
+        const weekLimits = isSubscriber ? resolved.week.subscriber : resolved.week.nonSubscriber;
+        const blockedAttemptsDay = isSubscriber
+            ? resolved.blockedAttemptsDay.subscriber
+            : resolved.blockedAttemptsDay.nonSubscriber;
+        if (!resolved.enabled) {
+            console.info(JSON.stringify({
+                msg: 'antifraud_card_volume_skipped',
+                source: resolved.source,
+                enabled: false,
+                checkoutId: checkout.id,
+                isSubscriber,
+            }));
+            return true;
+        }
+        console.info(JSON.stringify({
+            msg: 'antifraud_card_volume_limits',
+            source: resolved.source,
+            enabled: true,
+            checkoutId: checkout.id,
+            isSubscriber,
+            blockedAttemptsDay,
+            day: dayLimits,
+            week: weekLimits,
+        }));
+        await this.validateBlockedOrderAttempts(checkout, card, blockedAttemptsDay);
+        await this.validateDayAndWeekOrderLimits(checkout, card, dayLimits, weekLimits);
         return true;
     }
-    setLimitsByUserType(isSubscriber) {
-        this.LIMIT_ORDERS_DAY = {
-            subscriber: {
-                cpf: 4,
-                email: 4,
-                phone: 4,
-                card: 4,
-                zip: 4,
-            },
-            nonSubscriber: {
-                cpf: 2,
-                email: 2,
-                phone: 2,
-                card: 2,
-                zip: 2,
-            },
-        };
-        this.LIMIT_ORDERS_WEEK = {
-            subscriber: {
-                cpf: 12,
-                email: 12,
-                phone: 12,
-                card: 12,
-                zip: Infinity,
-            },
-            nonSubscriber: {
-                cpf: 7,
-                email: 7,
-                phone: 7,
-                card: 7,
-                zip: Infinity,
-            },
-        };
-        this.LIMIT_BLOCKED_ORDERS_DAY = isSubscriber ? 7 : 5;
-    }
-    getLimitsByUserType(type, isSubscriber) {
-        const limits = type === 'day' ? this.LIMIT_ORDERS_DAY : this.LIMIT_ORDERS_WEEK;
-        return isSubscriber ? limits['subscriber'] : limits['nonSubscriber'];
+    async loadResolvedLimits() {
+        if (!this.shopConfigsRepository) {
+            return resolveAntifraudVolumeLimits(null);
+        }
+        try {
+            const result = await this.shopConfigsRepository.find({}, { cache: { enabled: true, ttl: ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS } });
+            return resolveAntifraudVolumeLimits(result?.data?.at(0)?.antifraude);
+        }
+        catch (error) {
+            console.warn(JSON.stringify({
+                msg: 'antifraud_card_volume_config_load_failed',
+                source: 'fallback',
+                error: error instanceof Error ? error.message : String(error),
+            }));
+            return resolveAntifraudVolumeLimits(null);
+        }
     }
-    async validateBlockedOrderAttempts(checkout, card) {
-        const isValid = await this.verifyBlockedOrderAttempts(checkout, card);
+    async validateBlockedOrderAttempts(checkout, card, blockedAttemptsDay) {
+        const isValid = await this.verifyBlockedOrderAttempts(checkout, card, blockedAttemptsDay);
         if (!isValid) {
-            throw new FraudValidationError(`Cliente com mais de ${this.LIMIT_BLOCKED_ORDERS_DAY} compras negadas/bloqueadas no dia`, exports.ErrorsCode.fraudPreventionInternal, {
+            throw new FraudValidationError(`Cliente com mais de ${blockedAttemptsDay} compras negadas/bloqueadas no dia`, exports.ErrorsCode.fraudPreventionInternal, {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: {
@@ -1999,8 +2159,8 @@ class AntifraudCardService {
             });
         }
     }
-    async validateDayAndWeekOrderLimits(checkout, card) {
-        const isValid = await this.verifyDayAndWeekOrders(checkout, card);
+    async validateDayAndWeekOrderLimits(checkout, card, dayLimits, weekLimits) {
+        const isValid = await this.verifyDayAndWeekOrders(checkout, card, dayLimits, weekLimits);
         if (!isValid) {
             throw new FraudValidationError('Cliente tentando comprar mais do que o permitido no dia/semana', exports.ErrorsCode.fraudPreventionInternal, {
                 checkoutId: checkout.id,
@@ -2013,15 +2173,15 @@ class AntifraudCardService {
             });
         }
     }
-    async verifyBlockedOrderAttempts(checkout, card) {
+    async verifyBlockedOrderAttempts(checkout, card, blockedAttemptsDay) {
         const dateRange = this.getTodayDateRange();
         const blockedOrders = await this.getBlockedOrdersByMultipleCriteria(checkout, dateRange);
         const totalBlockedAttempts = this.calculateUniqueBlockedAttempts(blockedOrders, checkout);
-        if (totalBlockedAttempts >= this.LIMIT_BLOCKED_ORDERS_DAY) {
+        if (totalBlockedAttempts >= blockedAttemptsDay) {
             await this.createBlockedOrderRecord({
                 checkout,
                 card,
-                reason: `More than ${this.LIMIT_BLOCKED_ORDERS_DAY} attempts have failed`,
+                reason: `More than ${blockedAttemptsDay} attempts have failed`,
                 key: 'Failed attempts',
                 period: 'day',
             });
@@ -2123,12 +2283,12 @@ class AntifraudCardService {
             card,
         });
     }
-    async verifyDayAndWeekOrders(checkout, card) {
+    async verifyDayAndWeekOrders(checkout, card, dayLimits, weekLimits) {
         const validationParams = this.buildValidationParams(checkout, card);
-        const isDayLimitValid = await this.validateDayOrderLimits(checkout, validationParams);
+        const isDayLimitValid = await this.validateDayOrderLimits(checkout, validationParams, dayLimits);
         if (!isDayLimitValid)
             return false;
-        const isWeekLimitValid = await this.validateWeekOrderLimits(checkout, validationParams);
+        const isWeekLimitValid = await this.validateWeekOrderLimits(checkout, validationParams, weekLimits);
         return isWeekLimitValid;
     }
     buildValidationParams(checkout, card) {
@@ -2140,9 +2300,8 @@ class AntifraudCardService {
             card,
         };
     }
-    async validateDayOrderLimits(checkout, params) {
+    async validateDayOrderLimits(checkout, params, limits) {
         const ordersPerDay = await this.validateOrdersByRange(params, this.getDateRange('day'));
-        const limits = this.getLimitsByUserType('day', checkout.user.isSubscriber);
         return this.checkOrderLimitsAndBlock({
             checkout,
             orderCounts: ordersPerDay,
@@ -2150,9 +2309,8 @@ class AntifraudCardService {
             period: 'day',
         });
     }
-    async validateWeekOrderLimits(checkout, params) {
+    async validateWeekOrderLimits(checkout, params, limits) {
         const ordersPerWeek = await this.validateOrdersByRange(params, this.getDateRange('week'));
-        const limits = this.getLimitsByUserType('week', checkout.user.isSubscriber);
         return this.checkOrderLimitsAndBlock({
             checkout,
             orderCounts: ordersPerWeek,
@@ -2229,15 +2387,35 @@ class AntifraudCardService {
 }
 
 class AntifraudGlampointsService {
-    constructor() { }
-    async validate(_checkout) {
+    constructor(shopConfigsRepository) {
+        this.shopConfigsRepository = shopConfigsRepository;
+    }
+    async validate(checkout) {
+        const enabled = await isAntifraudEnabled(this.shopConfigsRepository);
+        if (!enabled) {
+            console.info(JSON.stringify({
+                msg: 'antifraud_glampoints_skipped',
+                enabled: false,
+                checkoutId: checkout.id,
+            }));
+        }
         return true;
     }
 }
 
 class AntifraudPixService {
-    constructor() { }
-    async validate(_checkout) {
+    constructor(shopConfigsRepository) {
+        this.shopConfigsRepository = shopConfigsRepository;
+    }
+    async validate(checkout) {
+        const enabled = await isAntifraudEnabled(this.shopConfigsRepository);
+        if (!enabled) {
+            console.info(JSON.stringify({
+                msg: 'antifraud_pix_skipped',
+                enabled: false,
+                checkoutId: checkout.id,
+            }));
+        }
         return true;
     }
 }
@@ -2591,6 +2769,26 @@ class ShopSettings extends BaseModel {
     }
 }
 
+/**
+ * Defaults iguais ao hardcode histórico do checkout.
+ * `week.*.zip = null` → Infinity no runtime do volume de cartão.
+ */
+const DEFAULT_SHOP_ANTIFRAUD_CONFIG = {
+    enabled: true,
+    day: {
+        subscriber: { cpf: 4, email: 4, phone: 4, card: 4, zip: 4 },
+        nonSubscriber: { cpf: 2, email: 2, phone: 2, card: 2, zip: 2 },
+    },
+    week: {
+        subscriber: { cpf: 12, email: 12, phone: 12, card: 12, zip: null },
+        nonSubscriber: { cpf: 7, email: 7, phone: 7, card: 7, zip: null },
+    },
+    blockedAttemptsDay: {
+        subscriber: 7,
+        nonSubscriber: 5,
+    },
+};
+
 class AdyenBlockedOrderHelper {
     static async handleUnauthorizedPayment(params) {
         await params.orderBlockedRepository.createBlockedOrderOrPayment({
@@ -5474,7 +5672,7 @@ class CampaignHashtagFirestoreRepository extends withCrudFirestore(withHelpers(w
     constructor({ firestore, interceptors, cache, }) {
         super({
             firestore,
-            collectionName: 'hashtagCampaignsAuto',
+            collectionName: 'CampaignsHashtags',
             model: CampaignHashtag,
             interceptors,
             cache,
@@ -5482,6 +5680,18 @@ class CampaignHashtagFirestoreRepository extends withCrudFirestore(withHelpers(w
     }
 }
 
+class CampaignHashtagPostsFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, cache, }) {
+        super({
+            firestore,
+            collectionName: 'CampaignsHashtagsPosts',
+            model: CampaignHashtagPosts,
+            interceptors,
+            cache,
+        });
+    }
+}
+
 class CheckoutFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
     constructor({ firestore, interceptors, cache, }) {
         super({
@@ -5637,6 +5847,18 @@ class PaymentFirestoreRepository extends withCrudFirestore(withHelpers(withFires
     }
 }
 
+class PendingOrderFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, cache, }) {
+        super({
+            firestore,
+            collectionName: 'transId',
+            model: PendingOrder,
+            interceptors,
+            cache,
+        });
+    }
+}
+
 class ShoppingRecurrenceEditionFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
     constructor({ firestore, interceptors, cache, }) {
         super({
@@ -11715,6 +11937,7 @@ Object.defineProperty(exports, 'unset', {
   enumerable: true,
   get: function () { return lodash.unset; }
 });
+exports.ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS = ANTIFRAUD_CONFIG_CACHE_TTL_SECONDS;
 exports.Address = Address;
 exports.AdyenCardAxiosAdapter = AdyenCardAxiosAdapter;
 exports.AdyenPaymentMethodFactory = AdyenPaymentMethodFactory;
@@ -11741,6 +11964,8 @@ exports.CampaignDashboard = CampaignDashboard;
 exports.CampaignDashboardFirestoreRepository = CampaignDashboardFirestoreRepository;
 exports.CampaignHashtag = CampaignHashtag;
 exports.CampaignHashtagFirestoreRepository = CampaignHashtagFirestoreRepository;
+exports.CampaignHashtagPosts = CampaignHashtagPosts;
+exports.CampaignHashtagPostsFirestoreRepository = CampaignHashtagPostsFirestoreRepository;
 exports.Category = Category;
 exports.CategoryCollectionChildren = CategoryCollectionChildren;
 exports.CategoryCollectionChildrenHasuraGraphQLRepository = CategoryCollectionChildrenHasuraGraphQLRepository;
@@ -11762,6 +11987,8 @@ exports.ConnectDocumentService = ConnectDocumentService;
 exports.ConnectFirestoreService = ConnectFirestoreService;
 exports.Coupon = Coupon;
 exports.CouponFirestoreRepository = CouponFirestoreRepository;
+exports.DEFAULT_ANTIFRAUD_VOLUME_LIMITS = DEFAULT_ANTIFRAUD_VOLUME_LIMITS;
+exports.DEFAULT_SHOP_ANTIFRAUD_CONFIG = DEFAULT_SHOP_ANTIFRAUD_CONFIG;
 exports.Debug = Debug;
 exports.DebugDecoratorHelper = DebugDecoratorHelper;
 exports.DebugHelper = DebugHelper;
@@ -11817,6 +12044,8 @@ exports.PaymentError = PaymentError;
 exports.PaymentFirestoreRepository = PaymentFirestoreRepository;
 exports.PaymentProviderFactory = PaymentProviderFactory;
 exports.PaymentTransaction = PaymentTransaction;
+exports.PendingOrder = PendingOrder;
+exports.PendingOrderFirestoreRepository = PendingOrderFirestoreRepository;
 exports.Product = Product;
 exports.ProductCatalogHasuraGraphQL = ProductCatalogHasuraGraphQL;
 exports.ProductCatalogHasuraGraphQLRepository = ProductCatalogHasuraGraphQLRepository;
@@ -11898,10 +12127,12 @@ exports.WishlistHasuraGraphQLRepository = WishlistHasuraGraphQLRepository;
 exports.deserialize = deserialize;
 exports.getClass = getClass;
 exports.is = is;
+exports.isAntifraudEnabled = isAntifraudEnabled;
 exports.isDebuggable = isDebuggable;
 exports.isUUID = isUUID;
 exports.parseDateTime = parseDateTime;
 exports.registerClass = registerClass;
+exports.resolveAntifraudVolumeLimits = resolveAntifraudVolumeLimits;
 exports.resolveCacheConfig = resolveCacheConfig;
 exports.resolveClass = resolveClass;
 exports.serialize = serialize;