@contentful/optimization-api-client 0.1.0-alpha

package/dist/index.mjs

@@ -0,0 +1,583 @@
+import * as __rspack_external__contentful_optimization_api_schemas_66dcf407 from "@contentful/optimization-api-schemas";
+import { diary, enable } from "diary";
+import "diary/utils";
+import p_retry from "p-retry";
+import { merge } from "es-toolkit";
+import { boolean as mini_boolean, extend, number, object, optional, partial, prefault, string } from "zod/mini";
+class Logger {
+    name = '@contentful/optimization';
+    PREFIX_PARTS = [
+        'Ctfl',
+        'O10n'
+    ];
+    DELIMITER = ':';
+    diary;
+    sinks = [];
+    constructor(){
+        this.diary = diary(this.name, this.onLogEvent.bind(this));
+        enable(this.name);
+    }
+    assembleLocationPrefix(logLocation) {
+        return `[${[
+            ...this.PREFIX_PARTS,
+            logLocation
+        ].join(this.DELIMITER)}]`;
+    }
+    addSink(sink) {
+        this.sinks = [
+            ...this.sinks.filter((existingSink)=>existingSink.name !== sink.name),
+            sink
+        ];
+    }
+    removeSink(name) {
+        this.sinks = this.sinks.filter((sink)=>sink.name !== name);
+    }
+    removeSinks() {
+        this.sinks = [];
+    }
+    debug(logLocation, message, ...args) {
+        this.diary.debug(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+    }
+    info(logLocation, message, ...args) {
+        this.diary.info(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+    }
+    log(logLocation, message, ...args) {
+        this.diary.log(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+    }
+    warn(logLocation, message, ...args) {
+        this.diary.warn(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+    }
+    error(logLocation, message, ...args) {
+        this.diary.error(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+    }
+    fatal(logLocation, message, ...args) {
+        this.diary.fatal(`${this.assembleLocationPrefix(logLocation)} ${message}`, ...args);
+    }
+    onLogEvent(event) {
+        this.sinks.forEach((sink)=>{
+            sink.ingest(event);
+        });
+    }
+}
+const logger = new Logger();
+function createScopedLogger(location) {
+    return {
+        debug: (message, ...args)=>{
+            logger.debug(location, message, ...args);
+        },
+        info: (message, ...args)=>{
+            logger.info(location, message, ...args);
+        },
+        log: (message, ...args)=>{
+            logger.log(location, message, ...args);
+        },
+        warn: (message, ...args)=>{
+            logger.warn(location, message, ...args);
+        },
+        error: (message, ...args)=>{
+            logger.error(location, message, ...args);
+        },
+        fatal: (message, ...args)=>{
+            logger.fatal(location, message, ...args);
+        }
+    };
+}
+const createRetryFetchMethod_logger = createScopedLogger('ApiClient:Retry');
+const DEFAULT_INTERVAL_TIMEOUT = 0;
+const DEFAULT_RETRY_COUNT = 1;
+const RETRY_RESPONSE_STATUS = 503;
+const HTTP_ERROR_RESPONSE_STATUS = 500;
+class HttpError extends Error {
+    status;
+    constructor(message, status = HTTP_ERROR_RESPONSE_STATUS){
+        super(message);
+        Object.setPrototypeOf(this, HttpError.prototype);
+        this.status = status;
+    }
+}
+function createRetryFetchCallback({ apiName = 'Optimization', controller, fetchMethod = fetch, init, url }) {
+    return async ()=>{
+        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.ok) {
+                const httpError = new Error(`Request to "${url.toString()}" 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);
+            return response;
+        } catch (error) {
+            if (error instanceof HttpError && error.status === RETRY_RESPONSE_STATUS) throw error;
+            createRetryFetchMethod_logger.error(`Request to "${url.toString()}" failed:`, error);
+            controller.abort();
+        }
+    };
+}
+function createRetryFetchMethod({ apiName = 'Optimization', fetchMethod = fetch, intervalTimeout = DEFAULT_INTERVAL_TIMEOUT, onFailedAttempt, retries = DEFAULT_RETRY_COUNT } = {}) {
+    return async (url, init)=>{
+        const controller = new AbortController();
+        let retryResponse;
+        try {
+            retryResponse = await p_retry(createRetryFetchCallback({
+                apiName,
+                controller,
+                fetchMethod,
+                init,
+                url
+            }), {
+                minTimeout: intervalTimeout,
+                onFailedAttempt: (options)=>onFailedAttempt?.({
+                        ...options,
+                        apiName
+                    }),
+                retries,
+                signal: controller.signal
+            });
+        } catch (error) {
+            if (!(error instanceof Error) || 'AbortError' !== error.name) throw error;
+        }
+        if (!retryResponse) throw new Error(`${apiName} API request to "${url.toString()}" may not be retried.`);
+        return retryResponse;
+    };
+}
+const createTimeoutFetchMethod_logger = createScopedLogger('ApiClient:Timeout');
+const DEFAULT_REQUEST_TIMEOUT = 3000;
+function createTimeoutFetchMethod({ apiName = 'Optimization', fetchMethod = fetch, onRequestTimeout, requestTimeout = DEFAULT_REQUEST_TIMEOUT } = {}) {
+    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'));
+            controller.abort();
+        }, requestTimeout);
+        const response = await fetchMethod(url, {
+            ...init,
+            signal: controller.signal
+        });
+        clearTimeout(id);
+        return response;
+    };
+}
+const createProtectedFetchMethod_logger = createScopedLogger('ApiClient:Fetch');
+function createProtectedFetchMethod(options) {
+    try {
+        const timeoutFetchMethod = createTimeoutFetchMethod(options);
+        const retryFetchMethod = createRetryFetchMethod({
+            ...options,
+            fetchMethod: timeoutFetchMethod
+        });
+        return retryFetchMethod;
+    } catch (error) {
+        if (error instanceof Error) if ('AbortError' === error.name) createProtectedFetchMethod_logger.warn('Request aborted due to network issues. This request may not be retried.');
+        else createProtectedFetchMethod_logger.error('Request failed:', error);
+        throw error;
+    }
+}
+const Fetch = {
+    create: createProtectedFetchMethod
+};
+const fetch_Fetch = Fetch;
+const src_fetch = fetch_Fetch;
+const ApiClientBase_logger = createScopedLogger('ApiClient');
+const DEFAULT_ENVIRONMENT = 'main';
+class ApiClientBase {
+    name;
+    clientId;
+    environment;
+    fetch;
+    constructor(name, { fetchOptions, clientId, environment }){
+        this.clientId = clientId;
+        this.environment = environment ?? DEFAULT_ENVIRONMENT;
+        this.name = name;
+        this.fetch = src_fetch.create({
+            ...fetchOptions ?? {},
+            apiName: name
+        });
+    }
+    logRequestError(error, { requestName }) {
+        if (error instanceof Error) if ('AbortError' === error.name) ApiClientBase_logger.warn(`[${this.name}] "${requestName}" request aborted due to network issues. This request may not be retried.`);
+        else ApiClientBase_logger.error(`[${this.name}] "${requestName}" request failed:`, error);
+    }
+}
+const src_ApiClientBase = ApiClientBase;
+const ExperienceApiClient_logger = createScopedLogger('ApiClient:Experience');
+const EXPERIENCE_BASE_URL = 'https://experience.ninetailed.co/';
+class ExperienceApiClient extends src_ApiClientBase {
+    baseUrl;
+    enabledFeatures;
+    ip;
+    locale;
+    plainText;
+    preflight;
+    constructor(config){
+        super('Experience', config);
+        const { baseUrl, enabledFeatures, ip, locale, plainText, preflight } = config;
+        this.baseUrl = baseUrl || EXPERIENCE_BASE_URL;
+        this.enabledFeatures = enabledFeatures;
+        this.ip = ip;
+        this.locale = locale;
+        this.plainText = plainText;
+        this.preflight = preflight;
+    }
+    async getProfile(id, options = {}) {
+        if (!id) throw new Error('Valid profile ID required.');
+        const requestName = 'Get Profile';
+        ExperienceApiClient_logger.info(`Sending "${requestName}" request`);
+        try {
+            const response = await this.fetch(this.constructUrl(`v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${id}`, options), {
+                method: 'GET'
+            });
+            const { data: { changes, experiences, profile } } = __rspack_external__contentful_optimization_api_schemas_66dcf407.ExperienceResponse.parse(await response.json());
+            const data = {
+                changes,
+                personalizations: experiences,
+                profile
+            };
+            ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
+            return data;
+        } catch (error) {
+            this.logRequestError(error, {
+                requestName
+            });
+            throw error;
+        }
+    }
+    async makeProfileMutationRequest({ url, body, options }) {
+        return await this.fetch(this.constructUrl(url, options), {
+            method: 'POST',
+            headers: this.constructHeaders(options),
+            body: JSON.stringify(body),
+            keepalive: true
+        });
+    }
+    async createProfile({ events }, options = {}) {
+        const requestName = 'Create Profile';
+        ExperienceApiClient_logger.info(`Sending "${requestName}" request`);
+        const body = {
+            events: __rspack_external__contentful_optimization_api_schemas_66dcf407.ExperienceEventArray.parse(events),
+            options: this.constructBodyOptions(options)
+        };
+        ExperienceApiClient_logger.debug(`"${requestName}" request body:`, body);
+        try {
+            const response = await this.makeProfileMutationRequest({
+                url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles`,
+                body,
+                options
+            });
+            const { data: { changes, experiences, profile } } = __rspack_external__contentful_optimization_api_schemas_66dcf407.ExperienceResponse.parse(await response.json());
+            const data = {
+                changes,
+                personalizations: experiences,
+                profile
+            };
+            ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
+            return data;
+        } catch (error) {
+            this.logRequestError(error, {
+                requestName
+            });
+            throw error;
+        }
+    }
+    async updateProfile({ profileId, events }, options = {}) {
+        if (!profileId) throw new Error('Valid profile ID required.');
+        const requestName = 'Update Profile';
+        ExperienceApiClient_logger.info(`Sending "${requestName}" request`);
+        const body = {
+            events: __rspack_external__contentful_optimization_api_schemas_66dcf407.ExperienceEventArray.parse(events),
+            options: this.constructBodyOptions(options)
+        };
+        ExperienceApiClient_logger.debug(`"${requestName}" request body:`, body);
+        try {
+            const response = await this.makeProfileMutationRequest({
+                url: `v2/organizations/${this.clientId}/environments/${this.environment}/profiles/${profileId}`,
+                body,
+                options
+            });
+            const { data: { changes, experiences, profile } } = __rspack_external__contentful_optimization_api_schemas_66dcf407.ExperienceResponse.parse(await response.json());
+            const data = {
+                changes,
+                personalizations: experiences,
+                profile
+            };
+            ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
+            return data;
+        } catch (error) {
+            this.logRequestError(error, {
+                requestName
+            });
+            throw error;
+        }
+    }
+    async upsertProfile({ profileId, events }, options) {
+        if (!profileId) return await this.createProfile({
+            events
+        }, options);
+        return await this.updateProfile({
+            profileId,
+            events
+        }, options);
+    }
+    async upsertManyProfiles({ events }, options = {}) {
+        const requestName = 'Upsert Many Profiles';
+        ExperienceApiClient_logger.info(`Sending "${requestName}" request`);
+        const body = {
+            events: __rspack_external__contentful_optimization_api_schemas_66dcf407.ExperienceEventArray.parse(events),
+            options: this.constructBodyOptions(options)
+        };
+        ExperienceApiClient_logger.debug(`"${requestName}" request body:`, body);
+        try {
+            const response = await this.makeProfileMutationRequest({
+                url: `v2/organizations/${this.clientId}/environments/${this.environment}/events`,
+                body,
+                options: {
+                    plainText: false,
+                    ...options
+                }
+            });
+            const { data: { profiles } } = __rspack_external__contentful_optimization_api_schemas_66dcf407.BatchExperienceResponse.parse(await response.json());
+            ExperienceApiClient_logger.debug(`"${requestName}" request successfully completed`);
+            return profiles;
+        } catch (error) {
+            this.logRequestError(error, {
+                requestName
+            });
+            throw error;
+        }
+    }
+    constructUrl(path, options) {
+        const url = new URL(path, this.baseUrl);
+        const locale = options.locale ?? this.locale;
+        const preflight = options.preflight ?? this.preflight;
+        if (locale) url.searchParams.set('locale', locale);
+        if (preflight) url.searchParams.set('type', 'preflight');
+        return url.toString();
+    }
+    constructHeaders({ ip = this.ip, plainText = this.plainText }) {
+        const headers = new Map();
+        if (ip) headers.set('X-Force-IP', ip);
+        if (plainText ?? this.plainText ?? true) headers.set('Content-Type', 'text/plain');
+        else headers.set('Content-Type', 'application/json');
+        return Object.fromEntries(headers);
+    }
+    constructBodyOptions = ({ enabledFeatures = this.enabledFeatures })=>{
+        const bodyOptions = {};
+        if (enabledFeatures && Array.isArray(enabledFeatures) && enabledFeatures.length > 0) bodyOptions.features = enabledFeatures;
+        else bodyOptions.features = [
+            'ip-enrichment',
+            'location'
+        ];
+        return bodyOptions;
+    };
+}
+const experience = ExperienceApiClient;
+const InsightsApiClient_logger = createScopedLogger('ApiClient:Insights');
+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;
+        this.baseUrl = baseUrl ?? INSIGHTS_BASE_URL;
+        this.beaconHandler = beaconHandler;
+    }
+    async sendBatchEvents(batches, options = {}) {
+        const { beaconHandler = this.beaconHandler } = options;
+        const url = new URL(`v1/organizations/${this.clientId}/environments/${this.environment}/events`, this.baseUrl);
+        const body = __rspack_external__contentful_optimization_api_schemas_66dcf407.BatchInsightsEventArray.parse(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 requestName = 'Event Batches';
+        InsightsApiClient_logger.info(`Sending "${requestName}" request`);
+        InsightsApiClient_logger.debug(`"${requestName}" request body:`, body);
+        try {
+            await this.fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(body),
+                keepalive: true
+            });
+            InsightsApiClient_logger.debug(`"${requestName}" request successfully completed`);
+            return true;
+        } catch (error) {
+            this.logRequestError(error, {
+                requestName
+            });
+            return false;
+        }
+    }
+}
+const insights = InsightsApiClient;
+class ApiClient {
+    config;
+    experience;
+    insights;
+    constructor(config){
+        const { personalization, analytics, ...apiConfig } = config;
+        this.config = apiConfig;
+        this.experience = new experience({
+            ...apiConfig,
+            ...personalization
+        });
+        this.insights = new insights({
+            ...apiConfig,
+            ...analytics
+        });
+    }
+}
+const UniversalEventBuilderArgs = object({
+    campaign: optional(__rspack_external__contentful_optimization_api_schemas_66dcf407.Campaign),
+    locale: optional(string()),
+    location: optional(__rspack_external__contentful_optimization_api_schemas_66dcf407.GeoLocation),
+    page: optional(__rspack_external__contentful_optimization_api_schemas_66dcf407.Page),
+    screen: optional(__rspack_external__contentful_optimization_api_schemas_66dcf407.Screen),
+    userAgent: optional(string())
+});
+const ComponentViewBuilderArgs = extend(UniversalEventBuilderArgs, {
+    componentId: string(),
+    experienceId: optional(string()),
+    variantIndex: optional(number()),
+    sticky: optional(mini_boolean())
+});
+const IdentifyBuilderArgs = extend(UniversalEventBuilderArgs, {
+    traits: optional(__rspack_external__contentful_optimization_api_schemas_66dcf407.Traits),
+    userId: string()
+});
+const PageViewBuilderArgs = extend(UniversalEventBuilderArgs, {
+    properties: optional(partial(__rspack_external__contentful_optimization_api_schemas_66dcf407.Page))
+});
+const ScreenViewBuilderArgs = extend(UniversalEventBuilderArgs, {
+    name: string(),
+    properties: __rspack_external__contentful_optimization_api_schemas_66dcf407.Properties
+});
+const TrackBuilderArgs = extend(UniversalEventBuilderArgs, {
+    event: string(),
+    properties: optional(prefault(__rspack_external__contentful_optimization_api_schemas_66dcf407.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
+        };
+    }
+    buildComponentView(args) {
+        const { componentId, experienceId, variantIndex, ...universal } = ComponentViewBuilderArgs.parse(args);
+        return {
+            ...this.buildUniversalEventProperties(universal),
+            type: 'component',
+            componentType: 'Entry',
+            componentId,
+            experienceId,
+            variantIndex: variantIndex ?? 0
+        };
+    }
+    buildFlagView(args) {
+        return {
+            ...this.buildComponentView(args),
+            componentType: 'Variable'
+        };
+    }
+    buildIdentify(args) {
+        const { traits = {}, userId, ...universal } = IdentifyBuilderArgs.parse(args);
+        return {
+            ...this.buildUniversalEventProperties(universal),
+            type: 'identify',
+            traits,
+            userId
+        };
+    }
+    buildPageView(args = {}) {
+        const { properties = {}, ...universal } = PageViewBuilderArgs.parse(args);
+        const pageProperties = this.getPageProperties();
+        const merged = merge({
+            ...pageProperties,
+            title: pageProperties.title ?? DEFAULT_PAGE_PROPERTIES.title
+        }, properties);
+        const { context: { screen: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
+        const context = __rspack_external__contentful_optimization_api_schemas_66dcf407.PageEventContext.parse(universalContext);
+        return {
+            ...universalProperties,
+            context,
+            type: 'page',
+            properties: merged
+        };
+    }
+    buildScreenView(args) {
+        const { name, properties, ...universal } = ScreenViewBuilderArgs.parse(args);
+        const { context: { page: _, ...universalContext }, ...universalProperties } = this.buildUniversalEventProperties(universal);
+        const context = __rspack_external__contentful_optimization_api_schemas_66dcf407.ScreenEventContext.parse(universalContext);
+        return {
+            ...universalProperties,
+            context,
+            type: 'screen',
+            name,
+            properties
+        };
+    }
+    buildTrack(args) {
+        const { event, properties = {}, ...universal } = TrackBuilderArgs.parse(args);
+        return {
+            ...this.buildUniversalEventProperties(universal),
+            type: 'track',
+            event,
+            properties
+        };
+    }
+}
+const builders_EventBuilder = EventBuilder;
+export * from "@contentful/optimization-api-schemas";
+export { ApiClient, DEFAULT_PAGE_PROPERTIES, EXPERIENCE_BASE_URL, INSIGHTS_BASE_URL, builders_EventBuilder as EventBuilder };
+
+//# sourceMappingURL=index.mjs.map