@contentful/optimization-api-client 0.1.0-alpha9 → 1.0.0

package/dist/index.cjs

@@ -148,14 +148,27 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
+        createTimeoutFetchMethod: ()=>createTimeoutFetchMethod,
+        ExperienceApiClient: ()=>ExperienceApiClient,
+        createProtectedFetchMethod: ()=>createProtectedFetchMethod,
         EXPERIENCE_BASE_URL: ()=>EXPERIENCE_BASE_URL,
         ApiClient: ()=>ApiClient,
         INSIGHTS_BASE_URL: ()=>INSIGHTS_BASE_URL,
-        DEFAULT_PAGE_PROPERTIES: ()=>DEFAULT_PAGE_PROPERTIES,
-        EventBuilder: ()=>builders_EventBuilder
+        createRetryFetchMethod: ()=>createRetryFetchMethod,
+        InsightsApiClient: ()=>InsightsApiClient
     });
     const optimization_api_schemas_namespaceObject = require("@contentful/optimization-api-schemas");
     var logger = __webpack_require__("./src/logger.ts");
+    const fetchInputToString = (input)=>{
+        if ('string' == typeof input) return input;
+        return input.url;
+    };
+    const MISSING_FETCH_METHOD_MESSAGE = 'No fetch implementation available. Provide a fetchMethod.';
+    function resolveFetchMethod(fetchMethod) {
+        if (fetchMethod) return fetchMethod;
+        if ('function' == typeof globalThis.fetch) return globalThis.fetch.bind(globalThis);
+        throw new Error(MISSING_FETCH_METHOD_MESSAGE);
+    }
     const createRetryFetchMethod_logger = (0, logger.createScopedLogger)('ApiClient:Retry');
     const DEFAULT_INTERVAL_TIMEOUT = 0;
     const DEFAULT_RETRY_COUNT = 1;
@@ -169,22 +182,23 @@ var __webpack_exports__ = {};
             this.status = status;
         }
     }
-    function createRetryFetchCallback({ apiName = 'Optimization', controller, fetchMethod = fetch, init, url }) {
+    function createRetryFetchCallback({ apiName = 'Optimization', controller, fetchMethod, init, url }) {
         return async ()=>{
+            const urlLabel = fetchInputToString(url);
             try {
                 const response = await fetchMethod(url, init);
-                if (response.status === RETRY_RESPONSE_STATUS) throw new HttpError(`${apiName} API request to "${url.toString()}" failed with status: "[${response.status}] ${response.statusText}".`, RETRY_RESPONSE_STATUS);
+                if (response.status === RETRY_RESPONSE_STATUS) throw new HttpError(`${apiName} API request to "${urlLabel}" failed with status: "[${response.status}] ${response.statusText}".`, RETRY_RESPONSE_STATUS);
                 if (!response.ok) {
-                    const httpError = new Error(`Request to "${url.toString()}" failed with status: [${response.status}] ${response.statusText} - traceparent: ${response.headers.get('traceparent')}`);
+                    const httpError = new Error(`Request to "${urlLabel}" failed with status: [${response.status}] ${response.statusText} - traceparent: ${response.headers.get('traceparent')}`);
                     createRetryFetchMethod_logger.error('Request failed with non-OK status:', httpError);
                     controller.abort();
                     return;
                 }
-                createRetryFetchMethod_logger.debug(`Response from "${url.toString()}":`, response);
+                createRetryFetchMethod_logger.debug(`Response from "${urlLabel}":`, response);
                 return response;
             } catch (error) {
                 if (error instanceof HttpError && error.status === RETRY_RESPONSE_STATUS) throw error;
-                createRetryFetchMethod_logger.error(`Request to "${url.toString()}" failed:`, error);
+                createRetryFetchMethod_logger.error(`Request to "${urlLabel}" failed:`, error);
                 controller.abort();
             }
         };
@@ -197,14 +211,15 @@ var __webpack_exports__ = {};
         }, intervalTimeout);
         await promise;
     }
-    function createRetryFetchMethod({ apiName = 'Optimization', fetchMethod = fetch, intervalTimeout = DEFAULT_INTERVAL_TIMEOUT, onFailedAttempt, retries = DEFAULT_RETRY_COUNT } = {}) {
+    function createRetryFetchMethod({ apiName = 'Optimization', fetchMethod, intervalTimeout = DEFAULT_INTERVAL_TIMEOUT, onFailedAttempt, retries = DEFAULT_RETRY_COUNT } = {}) {
+        const resolvedFetchMethod = resolveFetchMethod(fetchMethod);
         return async (url, init)=>{
             const controller = new AbortController();
             const maxAttempts = retries + 1;
             const attemptFetch = createRetryFetchCallback({
                 apiName,
                 controller,
-                fetchMethod,
+                fetchMethod: resolvedFetchMethod,
                 init,
                 url
             });
@@ -224,25 +239,32 @@ var __webpack_exports__ = {};
                 if (0 === retriesLeft) throw error;
                 await delayRetry(intervalTimeout);
             }
-            throw new Error(`${apiName} API request to "${url.toString()}" may not be retried.`);
+            throw new Error(`${apiName} API request to "${fetchInputToString(url)}" may not be retried.`);
         };
     }
     const createTimeoutFetchMethod_logger = (0, logger.createScopedLogger)('ApiClient:Timeout');
     const DEFAULT_REQUEST_TIMEOUT = 3000;
-    function createTimeoutFetchMethod({ apiName = 'Optimization', fetchMethod = fetch, onRequestTimeout, requestTimeout = DEFAULT_REQUEST_TIMEOUT } = {}) {
+    function isFetchAbortSignal(signal) {
+        return 'object' == typeof signal && null !== signal;
+    }
+    function createTimeoutFetchMethod({ apiName = 'Optimization', fetchMethod, onRequestTimeout, requestTimeout = DEFAULT_REQUEST_TIMEOUT } = {}) {
+        const resolvedFetchMethod = resolveFetchMethod(fetchMethod);
         return async (url, init)=>{
             const controller = new AbortController();
             const id = setTimeout(()=>{
                 if ('function' == typeof onRequestTimeout) onRequestTimeout({
                     apiName
                 });
-                else createTimeoutFetchMethod_logger.error(`Request to "${url.toString()}" timed out`, new Error('Request timeout'));
+                else createTimeoutFetchMethod_logger.error(`Request to "${fetchInputToString(url)}" timed out`, new Error('Request timeout'));
                 controller.abort();
             }, requestTimeout);
-            const response = await fetchMethod(url, {
+            const { signal } = controller;
+            if (!isFetchAbortSignal(signal)) throw new Error('AbortController signal is not compatible with fetch.');
+            const requestInit = {
                 ...init,
-                signal: controller.signal
-            });
+                signal
+            };
+            const response = await resolvedFetchMethod(url, requestInit);
             clearTimeout(id);
             return response;
         };
@@ -266,7 +288,7 @@ var __webpack_exports__ = {};
         create: createProtectedFetchMethod
     };
     const fetch_Fetch = Fetch;
-    const src_fetch = fetch_Fetch;
+    const fetch = fetch_Fetch;
     const ApiClientBase_logger = (0, logger.createScopedLogger)('ApiClient');
     const DEFAULT_ENVIRONMENT = 'main';
     class ApiClientBase {
@@ -278,7 +300,7 @@ var __webpack_exports__ = {};
             this.clientId = clientId;
             this.environment = environment ?? DEFAULT_ENVIRONMENT;
             this.name = name;
-            this.fetch = src_fetch.create({
+            this.fetch = fetch.create({
                 ...fetchOptions ?? {},
                 apiName: name
             });
@@ -308,6 +330,9 @@ var __webpack_exports__ = {};
             this.plainText = plainText;
             this.preflight = preflight;
         }
+        setLocale(locale) {
+            this.locale = locale;
+        }
         async getProfile(id, options = {}) {
             if (!id) throw new Error('Valid profile ID required.');
             const requestName = 'Get Profile';
@@ -319,7 +344,7 @@ var __webpack_exports__ = {};
                 const { data: { changes, experiences, profile } } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.ExperienceResponse, await response.json());
                 const data = {
                     changes,
-                    personalizations: experiences,
+                    selectedOptimizations: experiences,
                     profile
                 };
                 ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
@@ -353,7 +378,7 @@ var __webpack_exports__ = {};
                 const { data: { changes, experiences, profile } } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.ExperienceResponse, await response.json());
                 const data = {
                     changes,
-                    personalizations: experiences,
+                    selectedOptimizations: experiences,
                     profile
                 };
                 ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
@@ -380,7 +405,7 @@ var __webpack_exports__ = {};
                 const { data: { changes, experiences, profile } } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.ExperienceResponse, await response.json());
                 const data = {
                     changes,
-                    personalizations: experiences,
+                    selectedOptimizations: experiences,
                     profile
                 };
                 ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
@@ -459,39 +484,43 @@ var __webpack_exports__ = {};
             });
         }
     }
-    const experience = ExperienceApiClient;
     const InsightsApiClient_logger = (0, logger.createScopedLogger)('ApiClient:Insights');
+    const BEACON_FALLBACK_MESSAGE = 'beacon failed; falling back to fetch';
     const INSIGHTS_BASE_URL = 'https://ingest.insights.ninetailed.co/';
     class InsightsApiClient extends src_ApiClientBase {
         baseUrl;
-        beaconHandler;
         constructor(config){
             super('Insights', config);
-            const { baseUrl, beaconHandler } = config;
+            const { baseUrl } = config;
             this.baseUrl = baseUrl || INSIGHTS_BASE_URL;
-            this.beaconHandler = beaconHandler;
         }
         async sendBatchEvents(batches, options = {}) {
-            const { beaconHandler = this.beaconHandler } = options;
+            const { beacon } = options;
             const url = new URL(`v1/organizations/${this.clientId}/environments/${this.environment}/events`, this.baseUrl);
+            const urlString = url.toString();
             const body = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.BatchInsightsEventArray, batches);
-            if ('function' == typeof beaconHandler) {
-                InsightsApiClient_logger.debug('Queueing events via beaconHandler');
-                const beaconSuccessfullyQueued = beaconHandler(url, body);
-                if (beaconSuccessfullyQueued) return true;
-                InsightsApiClient_logger.warn('beaconHandler failed to queue events; events will be emitted immediately via fetch');
+            const serializedBody = JSON.stringify(body);
+            if (beacon) {
+                InsightsApiClient_logger.debug('Queueing events via beacon');
+                try {
+                    const beaconSuccessfullyQueued = beacon(urlString, serializedBody);
+                    if (beaconSuccessfullyQueued) return true;
+                    InsightsApiClient_logger.warn(BEACON_FALLBACK_MESSAGE);
+                } catch (error) {
+                    InsightsApiClient_logger.warn(BEACON_FALLBACK_MESSAGE, error);
+                }
             }
             const requestName = 'Event Batches';
             InsightsApiClient_logger.info(`Sending "${requestName}" request`);
             InsightsApiClient_logger.debug(`"${requestName}" request body:`, body);
             try {
-                await this.fetch(url, {
+                await this.fetch(urlString, {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json'
                     },
-                    body: JSON.stringify(body),
-                    keepalive: true
+                    body: serializedBody,
+                    keepalive: !!beacon
                 });
                 InsightsApiClient_logger.debug(`"${requestName}" request successfully completed`);
                 return true;
@@ -503,216 +532,46 @@ var __webpack_exports__ = {};
             }
         }
     }
-    const insights = InsightsApiClient;
     class ApiClient {
         config;
         experience;
         insights;
         constructor(config){
-            const { personalization, analytics, clientId, environment, fetchOptions } = config;
+            const { experience, insights, clientId, environment, fetchOptions } = config;
             const apiConfig = {
                 clientId,
                 environment,
                 fetchOptions
             };
             this.config = apiConfig;
-            this.experience = new experience({
+            this.experience = new ExperienceApiClient({
                 ...apiConfig,
-                ...personalization
+                ...experience
             });
-            this.insights = new insights({
+            this.insights = new InsightsApiClient({
                 ...apiConfig,
-                ...analytics
+                ...insights
             });
         }
     }
-    const object_namespaceObject = require("es-toolkit/object");
-    const mini_namespaceObject = require("zod/mini");
-    const UniversalEventBuilderArgs = mini_namespaceObject.object({
-        campaign: mini_namespaceObject.optional(optimization_api_schemas_namespaceObject.Campaign),
-        locale: mini_namespaceObject.optional(mini_namespaceObject.string()),
-        location: mini_namespaceObject.optional(optimization_api_schemas_namespaceObject.GeoLocation),
-        page: mini_namespaceObject.optional(optimization_api_schemas_namespaceObject.Page),
-        screen: mini_namespaceObject.optional(optimization_api_schemas_namespaceObject.Screen),
-        userAgent: mini_namespaceObject.optional(mini_namespaceObject.string())
-    });
-    const ComponentInteractionBuilderArgsBase = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-        componentId: mini_namespaceObject.string(),
-        experienceId: mini_namespaceObject.optional(mini_namespaceObject.string()),
-        variantIndex: mini_namespaceObject.optional(mini_namespaceObject.number())
-    });
-    const ComponentViewBuilderArgs = mini_namespaceObject.extend(ComponentInteractionBuilderArgsBase, {
-        sticky: mini_namespaceObject.optional(mini_namespaceObject.boolean()),
-        componentViewId: mini_namespaceObject.string(),
-        viewDurationMs: mini_namespaceObject.number()
-    });
-    const ComponentClickBuilderArgs = ComponentInteractionBuilderArgsBase;
-    const ComponentHoverBuilderArgs = mini_namespaceObject.extend(ComponentInteractionBuilderArgsBase, {
-        componentHoverId: mini_namespaceObject.string(),
-        hoverDurationMs: mini_namespaceObject.number()
-    });
-    const IdentifyBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-        traits: mini_namespaceObject.optional(optimization_api_schemas_namespaceObject.Traits),
-        userId: mini_namespaceObject.string()
-    });
-    const PageViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-        properties: mini_namespaceObject.optional(mini_namespaceObject.partial(optimization_api_schemas_namespaceObject.Page))
-    });
-    const ScreenViewBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-        name: mini_namespaceObject.string(),
-        properties: optimization_api_schemas_namespaceObject.Properties
-    });
-    const TrackBuilderArgs = mini_namespaceObject.extend(UniversalEventBuilderArgs, {
-        event: mini_namespaceObject.string(),
-        properties: mini_namespaceObject.optional(mini_namespaceObject.prefault(optimization_api_schemas_namespaceObject.Properties, {}))
-    });
-    const DEFAULT_PAGE_PROPERTIES = {
-        path: '',
-        query: {},
-        referrer: '',
-        search: '',
-        title: '',
-        url: ''
-    };
-    class EventBuilder {
-        app;
-        channel;
-        library;
-        getLocale;
-        getPageProperties;
-        getUserAgent;
-        constructor(config){
-            const { app, channel, library, getLocale, getPageProperties, getUserAgent } = config;
-            this.app = app;
-            this.channel = channel;
-            this.library = library;
-            this.getLocale = getLocale ?? (()=>'en-US');
-            this.getPageProperties = getPageProperties ?? (()=>DEFAULT_PAGE_PROPERTIES);
-            this.getUserAgent = getUserAgent ?? (()=>void 0);
-        }
-        buildUniversalEventProperties({ campaign = {}, locale, location, page, screen, userAgent }) {
-            const timestamp = new Date().toISOString();
-            return {
-                channel: this.channel,
-                context: {
-                    app: this.app,
-                    campaign,
-                    gdpr: {
-                        isConsentGiven: true
-                    },
-                    library: this.library,
-                    locale: locale ?? this.getLocale() ?? 'en-US',
-                    location,
-                    page: page ?? this.getPageProperties(),
-                    screen,
-                    userAgent: userAgent ?? this.getUserAgent()
-                },
-                messageId: crypto.randomUUID(),
-                originalTimestamp: timestamp,
-                sentAt: timestamp,
-                timestamp
-            };
-        }
-        buildEntryComponentBase(universal, componentId, experienceId, variantIndex) {
-            return {
-                ...this.buildUniversalEventProperties(universal),
-                componentType: 'Entry',
-                componentId,
-                experienceId,
-                variantIndex: variantIndex ?? 0
-            };
-        }
-        buildComponentView(args) {
-            const { componentId, componentViewId, experienceId, variantIndex, viewDurationMs, ...universal } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(ComponentViewBuilderArgs, args);
-            return {
-                ...this.buildEntryComponentBase(universal, componentId, experienceId, variantIndex),
-                type: 'component',
-                componentViewId,
-                viewDurationMs
-            };
-        }
-        buildComponentClick(args) {
-            const { componentId, experienceId, variantIndex, ...universal } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(ComponentClickBuilderArgs, args);
-            return {
-                ...this.buildEntryComponentBase(universal, componentId, experienceId, variantIndex),
-                type: 'component_click'
-            };
-        }
-        buildComponentHover(args) {
-            const { componentHoverId, componentId, experienceId, hoverDurationMs, variantIndex, ...universal } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(ComponentHoverBuilderArgs, args);
-            return {
-                ...this.buildEntryComponentBase(universal, componentId, experienceId, variantIndex),
-                type: 'component_hover',
-                componentHoverId,
-                hoverDurationMs
-            };
-        }
-        buildFlagView(args) {
-            return {
-                ...this.buildComponentView(args),
-                componentType: 'Variable'
-            };
-        }
-        buildIdentify(args) {
-            const { traits = {}, userId, ...universal } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(IdentifyBuilderArgs, args);
-            return {
-                ...this.buildUniversalEventProperties(universal),
-                type: 'identify',
-                traits,
-                userId
-            };
-        }
-        buildPageView(args = {}) {
-            const { properties = {}, ...universal } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(PageViewBuilderArgs, args);
-            const pageProperties = this.getPageProperties();
-            const merged = (0, object_namespaceObject.merge)({
-                ...pageProperties,
-                title: pageProperties.title ?? DEFAULT_PAGE_PROPERTIES.title
-            }, properties);
-            const { context: { screen: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
-            const context = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.PageEventContext, universalContext);
-            return {
-                ...universalProperties,
-                context,
-                type: 'page',
-                properties: merged
-            };
-        }
-        buildScreenView(args) {
-            const { name, properties, ...universal } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(ScreenViewBuilderArgs, args);
-            const { context: { page: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
-            const context = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(optimization_api_schemas_namespaceObject.ScreenEventContext, universalContext);
-            return {
-                ...universalProperties,
-                context,
-                type: 'screen',
-                name,
-                properties
-            };
-        }
-        buildTrack(args) {
-            const { event, properties = {}, ...universal } = (0, optimization_api_schemas_namespaceObject.parseWithFriendlyError)(TrackBuilderArgs, args);
-            return {
-                ...this.buildUniversalEventProperties(universal),
-                type: 'track',
-                event,
-                properties
-            };
-        }
-    }
-    const builders_EventBuilder = EventBuilder;
 })();
 exports.ApiClient = __webpack_exports__.ApiClient;
-exports.DEFAULT_PAGE_PROPERTIES = __webpack_exports__.DEFAULT_PAGE_PROPERTIES;
 exports.EXPERIENCE_BASE_URL = __webpack_exports__.EXPERIENCE_BASE_URL;
-exports.EventBuilder = __webpack_exports__.EventBuilder;
+exports.ExperienceApiClient = __webpack_exports__.ExperienceApiClient;
 exports.INSIGHTS_BASE_URL = __webpack_exports__.INSIGHTS_BASE_URL;
+exports.InsightsApiClient = __webpack_exports__.InsightsApiClient;
+exports.createProtectedFetchMethod = __webpack_exports__.createProtectedFetchMethod;
+exports.createRetryFetchMethod = __webpack_exports__.createRetryFetchMethod;
+exports.createTimeoutFetchMethod = __webpack_exports__.createTimeoutFetchMethod;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ApiClient",
-    "DEFAULT_PAGE_PROPERTIES",
     "EXPERIENCE_BASE_URL",
-    "EventBuilder",
-    "INSIGHTS_BASE_URL"
+    "ExperienceApiClient",
+    "INSIGHTS_BASE_URL",
+    "InsightsApiClient",
+    "createProtectedFetchMethod",
+    "createRetryFetchMethod",
+    "createTimeoutFetchMethod"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true