@envive-ai/react-hooks 0.2.6-alpha → 0.2.6-alpha-2

package/dist/src/application/models/validators/validateGraphQLFrontendConfig.js

@@ -1,420 +0,0 @@
-import { DOMInsertionType, GridInsertionType, PageVariantTestType, } from '@envive-ai/types';
-import Logger from 'src/application/logging/logger';
-import { transformSnakeToCamel } from '../utils/snakeToCamelTransformer';
-// Helper function to validate and transform PageVariantQueryData to PageVariantConfig
-export const validateAndTransformPageVariants = (config) => {
-    const transformed = transformSnakeToCamel(config);
-    const { variantChecks, widgetMounting, ...rest } = transformed;
-    // Convert variantChecks to variantTests with testType normalization
-    const variantTests = Array.isArray(variantChecks)
-        ? variantChecks.map(({ checkType, ...restCheck }) => ({
-            ...restCheck,
-            testType: checkType,
-        }))
-        : [];
-    // Normalize widgetMounting: checks -> tests, checkType -> testType
-    const normalizedWidgetMounting = Array.isArray(widgetMounting)
-        ? widgetMounting.map(({ mountingPointWidgets, ...restMounting }) => ({
-            ...restMounting,
-            ...(Array.isArray(mountingPointWidgets)
-                ? {
-                    mountingPointWidgets: mountingPointWidgets.map(({ checks, ...restWidget }) => ({
-                        ...restWidget,
-                        tests: Array.isArray(checks)
-                            ? checks.map(({ checkType, ...restCheck }) => ({
-                                ...restCheck,
-                                testType: checkType,
-                            }))
-                            : [],
-                    })),
-                }
-                : {}),
-        }))
-        : [];
-    const normalizedConfig = {
-        ...rest,
-        ...(variantTests ? { variantTests } : {}),
-        ...(normalizedWidgetMounting ? { widgetMounting: normalizedWidgetMounting } : {}),
-    };
-    const variantId = normalizedConfig.variantId;
-    const variantType = normalizedConfig.variantType;
-    if (typeof variantId !== 'string' || !variantId) {
-        throw new Error(`Missing or invalid variantId for pageVariant`);
-    }
-    if (typeof variantType !== 'string' || !variantType) {
-        throw new Error(`Missing or invalid variantType for pageVariant '${variantId}'`);
-    }
-    if (!Array.isArray(variantTests)) {
-        throw new Error(`Missing or invalid variantTests for pageVariant '${variantId}'. Must be an array`);
-    }
-    for (const test of variantTests) {
-        if (!test.testType || typeof test.testType !== 'string') {
-            throw new Error(`Invalid variantTest.testType for pageVariant '${variantId}'`);
-        }
-        if (!Object.values(PageVariantTestType).includes(test.testType)) {
-            throw new Error(`Invalid testType '${test.testType}' for pageVariant '${variantId}'. Valid types: ${Object.values(PageVariantTestType).join(', ')}`);
-        }
-    }
-    if (!Array.isArray(normalizedWidgetMounting)) {
-        throw new Error(`Missing or invalid widgetMounting for pageVariant '${variantId}'. Must be an array`);
-    }
-    for (const mounting of normalizedWidgetMounting) {
-        if (typeof mounting.mountingConfigId !== 'string' || !mounting.mountingConfigId) {
-            throw new Error(`Invalid mountingConfigId in widgetMounting for pageVariant '${variantId}'`);
-        }
-        if (mounting.widgetConfigId && typeof mounting.widgetConfigId !== 'string') {
-            throw new Error(`Invalid widgetConfigId in widgetMounting for pageVariant '${variantId}'`);
-        }
-        if (mounting.mountingPointWidgets) {
-            for (const widget of mounting.mountingPointWidgets) {
-                if (typeof widget.widgetConfigId !== 'string' || !widget.widgetConfigId) {
-                    throw new Error(`Invalid widgetConfigId in mountingPointWidgets for pageVariant '${variantId}'`);
-                }
-                if (!Array.isArray(widget.tests)) {
-                    throw new Error(`Invalid or missing tests in mountingPointWidgets for pageVariant '${variantId}'`);
-                }
-            }
-        }
-    }
-    if (variantType === 'plp') {
-        if (typeof normalizedConfig.plpIdExtractor !== 'string' || !normalizedConfig.plpIdExtractor) {
-            throw new Error(`Missing or invalid plpIdExtractor for PLP pageVariant '${variantId}'`);
-        }
-    }
-    if (variantType === 'pdp') {
-        if (typeof normalizedConfig.productIdExtractor !== 'string' ||
-            !normalizedConfig.productIdExtractor) {
-            throw new Error(`Missing or invalid productIdExtractor for PDP pageVariant '${variantId}'`);
-        }
-        if (normalizedConfig.parentProductIdExtractor &&
-            typeof normalizedConfig.parentProductIdExtractor !== 'string') {
-            throw new Error(`Invalid parentProductIdExtractor for PDP pageVariant '${variantId}'. Must be string if provided`);
-        }
-    }
-    return normalizedConfig;
-};
-// Helper function to validate and transform MountingConfigQueryData to WidgetMountingConfig
-export const validateAndTransformMountingConfig = (config, configKey) => {
-    // RENAMING LOGIC: Convert backend "Check" terminology to frontend "Test" terminology
-    const normalizedConfig = { ...config };
-    // Convert checkId to testId for frontend compatibility (data is already camelCase)
-    if (normalizedConfig.checkId && !normalizedConfig.testId) {
-        normalizedConfig.testId = normalizedConfig.checkId;
-        delete normalizedConfig.checkId;
-    }
-    // Required fields - these must be present and valid
-    if (typeof normalizedConfig.mountingConfigId !== 'string' || !normalizedConfig.mountingConfigId) {
-        throw new Error(`Missing or invalid mountingConfigId for config '${configKey}'`);
-    }
-    if (typeof normalizedConfig.containerId !== 'string' || !normalizedConfig.containerId) {
-        throw new Error(`Missing or invalid containerId for config '${configKey}'`);
-    }
-    if (typeof normalizedConfig.testId !== 'string' || !normalizedConfig.testId) {
-        throw new Error(`Missing or invalid testId for config '${configKey}'`);
-    }
-    // Required insertionPoint
-    if (!normalizedConfig.insertionPoint ||
-        typeof normalizedConfig.insertionPoint !== 'object' ||
-        Array.isArray(normalizedConfig.insertionPoint)) {
-        throw new Error(`Missing or invalid insertionPoint for config '${configKey}'`);
-    }
-    const insertionPoint = normalizedConfig.insertionPoint;
-    // Validate insertionPoint required fields
-    if (typeof insertionPoint.selector !== 'string' || !insertionPoint.selector) {
-        throw new Error(`Missing or invalid insertionPoint.selector for config '${configKey}'`);
-    }
-    if (typeof insertionPoint.insertionType !== 'string' || !insertionPoint.insertionType) {
-        throw new Error(`Missing or invalid insertionPoint.insertionType for config '${configKey}'`);
-    }
-    // Validate insertionType is a valid DOMInsertionType
-    if (!Object.values(DOMInsertionType).includes(insertionPoint.insertionType)) {
-        throw new Error(`Invalid insertionPoint.insertionType '${insertionPoint.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(', ')}`);
-    }
-    // Validate optional insertionPoint fields
-    if (insertionPoint.selectionIndex != null && typeof insertionPoint.selectionIndex !== 'number') {
-        throw new Error(`Invalid insertionPoint.selectionIndex for config '${configKey}'. Must be a number or null/undefined`);
-    }
-    // Validate optional parentInsertionPoint if present
-    let parentInsertionPoint;
-    if (normalizedConfig.parentInsertionPoint) {
-        if (typeof normalizedConfig.parentInsertionPoint !== 'object' ||
-            Array.isArray(normalizedConfig.parentInsertionPoint)) {
-            throw new Error(`Invalid parentInsertionPoint for config '${configKey}'. Must be an object`);
-        }
-        const parentPoint = normalizedConfig.parentInsertionPoint;
-        if (typeof parentPoint.selector !== 'string' || !parentPoint.selector) {
-            throw new Error(`Missing or invalid parentInsertionPoint.selector for config '${configKey}'`);
-        }
-        if (typeof parentPoint.insertionType !== 'string' || !parentPoint.insertionType) {
-            throw new Error(`Missing or invalid parentInsertionPoint.insertionType for config '${configKey}'`);
-        }
-        if (!Object.values(DOMInsertionType).includes(parentPoint.insertionType)) {
-            throw new Error(`Invalid parentInsertionPoint.insertionType '${parentPoint.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(', ')}`);
-        }
-        if (parentPoint.selectionIndex != null && typeof parentPoint.selectionIndex !== 'number') {
-            throw new Error(`Invalid parentInsertionPoint.selectionIndex for config '${configKey}'. Must be a number or null/undefined`);
-        }
-        parentInsertionPoint = {
-            selector: parentPoint.selector,
-            insertionType: parentPoint.insertionType,
-            selectionIndex: parentPoint.selectionIndex,
-        };
-    }
-    // Validate optional wrappingElement if present
-    let wrappingElement;
-    if (normalizedConfig.wrappingElement) {
-        if (typeof normalizedConfig.wrappingElement !== 'object' ||
-            Array.isArray(normalizedConfig.wrappingElement)) {
-            throw new Error(`Invalid wrappingElement for config '${configKey}'. Must be an object`);
-        }
-        const wrapping = normalizedConfig.wrappingElement;
-        if (typeof wrapping.className !== 'string' || !wrapping.className) {
-            throw new Error(`Missing or invalid wrappingElement.className for config '${configKey}'`);
-        }
-        if (typeof wrapping.element !== 'string' || !wrapping.element) {
-            throw new Error(`Missing or invalid wrappingElement.element for config '${configKey}'`);
-        }
-        if (typeof wrapping.insertionType !== 'string' || !wrapping.insertionType) {
-            throw new Error(`Missing or invalid wrappingElement.insertionType for config '${configKey}'`);
-        }
-        if (!Object.values(DOMInsertionType).includes(wrapping.insertionType)) {
-            throw new Error(`Invalid wrappingElement.insertionType '${wrapping.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(', ')}`);
-        }
-        wrappingElement = {
-            className: wrapping.className,
-            element: wrapping.element,
-            insertionType: wrapping.insertionType,
-        };
-    }
-    // Validate optional fields
-    if (normalizedConfig.divCheckSelector != null &&
-        typeof normalizedConfig.divCheckSelector !== 'string') {
-        throw new Error(`Invalid divCheckSelector for config '${configKey}'. Must be a string or null/undefined`);
-    }
-    if (normalizedConfig.className != null && typeof normalizedConfig.className !== 'string') {
-        throw new Error(`Invalid className for config '${configKey}'. Must be a string or null/undefined`);
-    }
-    if (normalizedConfig.suppressionSelector != null &&
-        typeof normalizedConfig.suppressionSelector !== 'string') {
-        throw new Error(`Invalid suppressionSelector for config '${configKey}'. Must be a string or null/undefined`);
-    }
-    if (normalizedConfig.dataAttributes != null &&
-        (typeof normalizedConfig.dataAttributes !== 'object' ||
-            Array.isArray(normalizedConfig.dataAttributes))) {
-        throw new Error(`Invalid dataAttributes for config '${configKey}'. Must be an object or null/undefined`);
-    }
-    if (normalizedConfig.style != null &&
-        (typeof normalizedConfig.style !== 'object' || Array.isArray(normalizedConfig.style))) {
-        throw new Error(`Invalid style for config '${configKey}'. Must be an object or null/undefined`);
-    }
-    // Validate gridInsertionType if present
-    let gridInsertionType;
-    if (normalizedConfig.gridInsertionType) {
-        if (typeof normalizedConfig.gridInsertionType !== 'string' ||
-            !normalizedConfig.gridInsertionType) {
-            throw new Error(`Invalid gridInsertionType for config '${configKey}'. Must be a string`);
-        }
-        if (!Object.values(GridInsertionType).includes(normalizedConfig.gridInsertionType)) {
-            throw new Error(`Invalid gridInsertionType '${normalizedConfig.gridInsertionType}' for config '${configKey}'. Valid types: ${Object.values(GridInsertionType).join(', ')}`);
-        }
-        gridInsertionType = normalizedConfig.gridInsertionType;
-    }
-    // Build the return object, only including optional fields if they have values
-    const result = {
-        mountingConfigId: normalizedConfig.mountingConfigId,
-        containerId: normalizedConfig.containerId,
-        testId: normalizedConfig.testId,
-        insertionPoint: {
-            selector: insertionPoint.selector,
-            insertionType: insertionPoint.insertionType,
-            ...(insertionPoint.selectionIndex != null && {
-                selectionIndex: insertionPoint.selectionIndex,
-            }),
-        },
-    };
-    // Only add optional fields if they have values
-    if (parentInsertionPoint) {
-        result.parentInsertionPoint = parentInsertionPoint;
-    }
-    if (gridInsertionType) {
-        result.gridInsertionType = gridInsertionType;
-    }
-    if (wrappingElement) {
-        result.wrappingElement = wrappingElement;
-    }
-    if (normalizedConfig.divCheckSelector) {
-        result.divCheckSelector = normalizedConfig.divCheckSelector;
-    }
-    if (normalizedConfig.className) {
-        result.className = normalizedConfig.className;
-    }
-    if (normalizedConfig.suppressionSelector) {
-        result.suppressionSelector = normalizedConfig.suppressionSelector;
-    }
-    if (normalizedConfig.dataAttributes) {
-        result.dataAttributes = normalizedConfig.dataAttributes;
-    }
-    if (normalizedConfig.style) {
-        result.style = normalizedConfig.style;
-    }
-    return result;
-};
-// Helper function to validate and transform WidgetConfigQueryData to WidgetConfig
-export const validateAndTransformWidgetConfig = (config, configKey) => {
-    const normalizedConfig = transformSnakeToCamel(config);
-    if (typeof normalizedConfig.widgetConfigId !== 'string' || !normalizedConfig.widgetConfigId) {
-        throw new Error(`Missing or invalid widgetConfigId for widget config '${configKey}'`);
-    }
-    if (typeof normalizedConfig.type !== 'string' || !normalizedConfig.type) {
-        throw new Error(`Missing or invalid type for widget config '${configKey}'`);
-    }
-    if (normalizedConfig.contentId != null && typeof normalizedConfig.contentId !== 'string') {
-        throw new Error(`Invalid contentId for widget config '${configKey}'. Must be a string or null/undefined`);
-    }
-    // Note: Widget configs are complex unions with type-specific properties.
-    // Return the normalized config as WidgetConfig
-    // Use intermediate 'unknown' cast for complex union types
-    return normalizedConfig;
-};
-export const validateGraphQLFrontendConfig = (data) => {
-    if (data === null || data === undefined) {
-        return undefined;
-    }
-    if (typeof data !== 'object' || Array.isArray(data)) {
-        Logger.logWarn('Invalid GraphQL frontend config data: not an object', undefined, { data });
-        return undefined;
-    }
-    const obj = data;
-    // Validate merchant_override_css if present
-    if ('merchant_override_css' in obj &&
-        typeof obj.merchant_override_css !== 'string' &&
-        obj.merchant_override_css !== null) {
-        Logger.logWarn('Invalid GraphQL frontend config data: merchant_override_css must be a string or null', undefined, { data });
-        return undefined;
-    }
-    // Validate page_variants if present
-    if ('page_variants' in obj) {
-        if (obj.page_variants !== undefined &&
-            obj.page_variants !== null &&
-            !Array.isArray(obj.page_variants)) {
-            Logger.logWarn('Invalid GraphQL frontend config data: page_variants must be an array or null/undefined', undefined, { data });
-            return undefined;
-        }
-    }
-    // Validate mounting_configs if present
-    if ('mounting_configs' in obj) {
-        if (obj.mounting_configs !== undefined &&
-            obj.mounting_configs !== null &&
-            !Array.isArray(obj.mounting_configs)) {
-            Logger.logWarn('Invalid GraphQL frontend config data: mounting_configs must be an array or null/undefined', undefined, { data });
-            return undefined;
-        }
-    }
-    // Validate widget_configs if present
-    if ('widget_configs' in obj) {
-        if (obj.widget_configs !== undefined &&
-            obj.widget_configs !== null &&
-            !Array.isArray(obj.widget_configs)) {
-            Logger.logWarn('Invalid GraphQL frontend config data: widget_configs must be an array or null/undefined', undefined, { data });
-            return undefined;
-        }
-    }
-    // Validate ui_configs if present
-    if ('ui_configs' in obj && typeof obj.ui_configs !== 'object' && obj.ui_configs !== null) {
-        Logger.logWarn('Invalid GraphQL frontend config data: ui_configs must be an object or null/undefined', undefined, { data });
-        return undefined;
-    }
-    try {
-        // Transform the data to camelCase
-        const transformedData = transformSnakeToCamel(obj);
-        // Convert page_variants from array to validated array if present
-        if (transformedData.pageVariants && Array.isArray(transformedData.pageVariants)) {
-            const pageVariantsArray = transformedData.pageVariants;
-            const validatedPageVariants = [];
-            for (const variant of pageVariantsArray) {
-                if (variant && typeof variant === 'object' && typeof variant.variantId === 'string') {
-                    try {
-                        const validatedVariant = validateAndTransformPageVariants(variant);
-                        validatedPageVariants.push(validatedVariant);
-                    }
-                    catch (error) {
-                        Logger.logWarn('Invalid page variant, skipping', error, {
-                            variantId: variant.variantId,
-                            variant,
-                        });
-                        // Continue processing other variants
-                    }
-                }
-                else {
-                    Logger.logWarn('Invalid page variant structure, skipping', undefined, { variant });
-                }
-            }
-            transformedData.pageVariants = validatedPageVariants;
-        }
-        // Convert mounting_configs from array to Record if present
-        if (transformedData.mountingConfigs && Array.isArray(transformedData.mountingConfigs)) {
-            const mountingConfigsArray = transformedData.mountingConfigs;
-            const mountingConfigsRecord = {};
-            for (const item of mountingConfigsArray) {
-                if (item &&
-                    typeof item.key === 'string' &&
-                    item.config &&
-                    typeof item.config === 'object') {
-                    try {
-                        // Validate and transform the config structure
-                        const config = item.config;
-                        const validatedConfig = validateAndTransformMountingConfig(config, item.key);
-                        mountingConfigsRecord[item.key] = validatedConfig;
-                    }
-                    catch (error) {
-                        Logger.logWarn('Invalid mounting config, skipping', error, {
-                            configKey: item.key,
-                            config: item.config,
-                        });
-                        // Continue processing other configs
-                    }
-                }
-                else {
-                    Logger.logWarn('Invalid mounting config item structure, skipping', undefined, { item });
-                }
-            }
-            transformedData.mountingConfigs = mountingConfigsRecord;
-        }
-        // Convert widget_configs from array to Record if present
-        if (transformedData.widgetConfigs && Array.isArray(transformedData.widgetConfigs)) {
-            const widgetConfigsArray = transformedData.widgetConfigs;
-            const widgetConfigsRecord = {};
-            for (const item of widgetConfigsArray) {
-                if (item &&
-                    typeof item.key === 'string' &&
-                    item.config &&
-                    typeof item.config === 'object') {
-                    try {
-                        // Validate and transform widget config using the dedicated validation function
-                        const config = item.config;
-                        const validatedConfig = validateAndTransformWidgetConfig(config, item.key);
-                        widgetConfigsRecord[item.key] = validatedConfig;
-                    }
-                    catch (error) {
-                        Logger.logWarn('Invalid widget config, skipping', error, {
-                            configKey: item.key,
-                            config: item.config,
-                        });
-                        // Continue processing other configs
-                    }
-                }
-                else {
-                    Logger.logWarn('Invalid widget config item structure, skipping', undefined, { item });
-                }
-            }
-            transformedData.widgetConfigs = widgetConfigsRecord;
-        }
-        return transformedData;
-    }
-    catch (error) {
-        Logger.logWarn('Failed to validate and transform GraphQL frontend config data', error, {
-            data,
-        });
-        return undefined;
-    }
-};

package/dist/src/application/models/validators/validateGraphQLOrgId.js

@@ -1,6 +0,0 @@
-export const validateGraphQLOrgId = (data) => {
-    if (typeof data !== 'string' || data === '') {
-        return undefined;
-    }
-    return data;
-};

package/dist/src/application/models/validators/validateMobilePLPChatPlacementParameter.js

@@ -1,9 +0,0 @@
-import { isMobilePLPChatPlacementParameter } from '../guards/isMobilePLPChatPlacementParameter';
-export const validateMobilePLPChatPlacementParameter = (value) => {
-    if (!isMobilePLPChatPlacementParameter(value)) {
-        return undefined;
-    }
-    return {
-        row_index: value.row_index,
-    };
-};

package/dist/src/application/models/validators/validateOrgConfigResults.js

@@ -1,44 +0,0 @@
-import { isApiOrgConfigResults } from "../guards/api/isApiOrgConfigResults";
-import { validateOrganizationConfig } from "./validateOrganizationConfig";
-/**
- *
- * @param data
- * @returns
- */
-export const validateOrgConfigResults = (data) => {
-    var _a, _b;
-    if (!isApiOrgConfigResults(data)) {
-        return undefined;
-    }
-    return {
-        configs: data.configs
-            .map((config) => validateOrganizationConfig(config))
-            .filter((config) => config != null),
-        experiments: data.experiments.map((experiment) => ({
-            group: experiment.group,
-            groupName: experiment.group_name,
-            name: experiment.name,
-            ruleId: experiment.rule_id,
-            // TODO this needs to be strongly typed but we're not running any experiments at the moment
-            value: experiment.value,
-        })),
-        gates: data.gates.map((gate) => ({
-            groupName: gate.group_name,
-            name: gate.name,
-            ruleId: gate.rule_id,
-            value: gate.value,
-        })),
-        org: {
-            org: {
-                id: data.org.org.id,
-                displayName: data.org.org.display_name,
-                domain: data.org.org.domain,
-                shortName: data.org.org.short_name,
-                status: data.org.org.status,
-                createdAt: (_a = data.org.org.created_at) === null || _a === void 0 ? void 0 : _a.toISOString(),
-                updatedAt: (_b = data.org.org.updated_at) === null || _b === void 0 ? void 0 : _b.toISOString(),
-            },
-            settings: {},
-        },
-    };
-};

package/dist/src/application/models/validators/validateOrganizationConfig.js

@@ -1,34 +0,0 @@
-import { isApiOrganizationConfig } from "../guards/api/isApiOrganizationConfig.js";
-export const validateOrganizationConfig = (data) => {
-    if (!isApiOrganizationConfig(data)) {
-        return undefined;
-    }
-    return {
-        id: data.id,
-        createdAt: data.createdAt,
-        namespace: data.namespace,
-        organizationId: data.organizationId,
-        isLatest: data.isLatest,
-        version: data.version,
-        updatedAt: data.updatedAt,
-        config: {
-            amplitude: data.config.amplitude
-                ? {
-                    sessionReplayEnabled: data.config.amplitude.session_replay_enabled,
-                    sessionReplaySampleRate: data.config.amplitude.session_replay_sample_rate,
-                    trackingEnabled: data.config.amplitude.tracking_enabled,
-                }
-                : undefined,
-            customerService: data.config.customer_service
-                ? {
-                    provider: data.config.customer_service.provider,
-                }
-                : undefined,
-            googleAnalytics: data.config.google_analytics
-                ? {
-                    measurementId: data.config.google_analytics.measurement_id,
-                }
-                : undefined,
-        },
-    };
-};