@schibsted/pulse-sdk 8.0.0-rc.20 → 8.0.0-rc.21

package/dist/ejs/tpaas-context/prepare.js

@@ -0,0 +1,137 @@
+import logger from 'loglevel';
+import { parsePulseCookies } from '../cis-sync';
+import * as identity from '../identity';
+import { SDK_VERSION } from '../version';
+import { mapPageToPageRef } from '../wrapper/utils/map-page-to-page-ref';
+import { adaptActorToNewFormat, adaptConsentsToNewFormat, adaptExperiments } from './adapters';
+import { captureBrowserContext } from './browser';
+import { resolveSession } from './session';
+// This looks overkill, but a mapping feels safer than doing string operations (capitalize) with javascript
+const mapDeployStageToTpaasStage = (deployStage) => {
+    switch (deployStage) {
+        case 'dev':
+            return 'Dev';
+        case 'pre':
+            return 'Pre';
+        case 'pro':
+            return 'Pro';
+    }
+};
+/**
+ * The context fields derived from the tracker state, shared by all TPaaS events.
+ */
+const getStateContext = (state) => ({
+    version: SDK_VERSION,
+    isHybrid: !!state.isHybrid,
+    pageviewId: state.pageViewId,
+    providerId: state.providerId,
+    providerName: state.provider?.name,
+    providerGroup: state.provider?.group,
+    providerStage: state.stage,
+    providerProduct: state.product,
+    providerVersion: state.version,
+    component: state.component,
+    componentVersion: state.componentVersion,
+    routingStage: mapDeployStageToTpaasStage(state.deployStageTpaas),
+});
+/**
+ * Deep copies the tracking input, so a caller that reuses and changes the same input object afterwards
+ * cannot change an event that is still being prepared. When the input cannot be copied, it is used as it is.
+ */
+const copyInput = (input) => {
+    try {
+        return structuredClone(input);
+    }
+    catch (ex) {
+        // older browsers, or inputs with values that cannot be cloned (functions, Promises, framework proxies)
+        logger.debug('Could not copy the tracking input, using it as is', ex);
+        return input;
+    }
+};
+const getPageRef = async (pageInfo) => {
+    const { id, type, url } = await pageInfo;
+    return mapPageToPageRef(id, type, url);
+};
+/**
+ * Resolves the context of an anonymous TPaaS event.
+ * Callers specify the event schema because it cannot be inferred from `InputParams<I>`.
+ *
+ * @private
+ */
+export async function prepareAnonymousTpaasEventContext(source, input) {
+    // Read everything before any asynchronous work, so the context reflects the moment the event
+    // was tracked and a later update or View event cannot change it.
+    const createdAt = new Date();
+    const eventInput = copyInput(input);
+    const browser = captureBrowserContext();
+    const stateContext = getStateContext(source.state);
+    const experiments = source.builders.experiments;
+    const { referrer } = source.currentPage;
+    try {
+        await source.applyRemoteConfig();
+    }
+    catch (ex) {
+        logger.trace('Failed to sync remote config', ex);
+    }
+    return {
+        input: eventInput,
+        createdAt,
+        browser,
+        ...stateContext,
+        experiments: adaptExperiments(experiments),
+        currentPageReferrer: await referrer,
+    };
+}
+/**
+ * Resolves the context of a TPaaS event.
+ * Callers specify the event schema because it cannot be inferred from `InputParams<I>`.
+ *
+ * @private
+ */
+export async function prepareTpaasEventContext(source, input) {
+    // Read everything before any asynchronous work, so the context reflects the moment the event
+    // was tracked and a later update or View event cannot change it.
+    // The session is resolved here too, so sessions are updated in the order events are tracked.
+    const createdAt = new Date();
+    const eventInput = copyInput(input);
+    const session = resolveSession(createdAt);
+    const browser = captureBrowserContext();
+    const stateContext = getStateContext(source.state);
+    const builders = { ...source.builders };
+    const { info, content, sports, referrer } = source.currentPage;
+    // Session listeners run synchronously and may update the tracker or start another View.
+    // Notify them only after this event's context has been captured.
+    source.onSessionResolved();
+    try {
+        await source.syncRemoteResources(builders);
+    }
+    catch (ex) {
+        logger.trace('Failed to sync remote resources', ex);
+        // remote config and CIS failures are also ignored for the old track() method. doing the same here
+    }
+    // Consents are intentionally not read upfront. Read them after remote synchronization
+    // so a blocking tracking call can use newly resolved consents.
+    const [actor, consents, currentPage, currentPageReferrer] = await Promise.all([
+        identity.getActor(builders),
+        source.getConsents(),
+        getPageRef(info),
+        referrer,
+    ]);
+    const { environmentId, jwe } = parsePulseCookies();
+    return {
+        input: eventInput,
+        createdAt,
+        session,
+        browser,
+        ...stateContext,
+        user: adaptActorToNewFormat(actor),
+        consents: adaptConsentsToNewFormat(consents),
+        experiments: adaptExperiments(builders.experiments),
+        currentPage,
+        currentPageContent: content,
+        currentPageSports: sports,
+        currentPageReferrer,
+        environmentId,
+        jwe,
+    };
+}

package/dist/ejs/tpaas-context/session.js

@@ -0,0 +1,19 @@
+import { touchSession } from '../session/store';
+import { getXDomainId } from '../utils';
+/**
+ * Registers an event created at `createdAt` in the stored session and returns it in the TPaaS format.
+ *
+ * Call it synchronously, together with capturing `createdAt`, before any asynchronous work.
+ * Sessions are then updated in the order events are tracked, which is also their creation order.
+ *
+ * @private
+ */
+export const resolveSession = (createdAt) => {
+    const { sessionId, startTime, isFirstEvent } = touchSession(createdAt);
+    return {
+        isFirstEvent,
+        sessionId,
+        startTime: startTime.toISOString(),
+        xDomainId: getXDomainId(),
+    };
+};