@streamscloud/streams-analytics-collector 2.0.10 → 3.0.0

package/dist/analytics-collector.d.ts

@@ -0,0 +1,24 @@
+import { AppearanceEventsTracker } from './appearance-events-tracker';
+import { MeasurementsBatcher } from './measurements-batcher';
+import { type AnalyticsMetadata, type AnalyticsSchema, type GqlDataSenderOptions, EventsReporter, MeasurementsReporter } from './reporting';
+export type AnalyticsCollectorInitOptions = {
+    gqlDataSenderOptions: GqlDataSenderOptions;
+    schema: AnalyticsSchema;
+    metadata?: AnalyticsMetadata | null;
+};
+declare class AnalyticsCollectorContainer {
+    private _eventsReporter?;
+    private _measurementsReporter?;
+    private _appearanceEventsTracker?;
+    private _measurementsBatcher?;
+    private _isInitialized;
+    initialize(options: AnalyticsCollectorInitOptions): void;
+    get eventsReporter(): EventsReporter;
+    get measurementsReporter(): MeasurementsReporter;
+    get appearanceEventsTracker(): AppearanceEventsTracker;
+    get measurementsBatcher(): MeasurementsBatcher;
+    get isInitialized(): boolean;
+    private assertInitialized;
+}
+export declare const AnalyticsCollector: AnalyticsCollectorContainer;
+export {};

package/dist/analytics-collector.js

@@ -0,0 +1,51 @@
+import { AppearanceEventsTracker } from './appearance-events-tracker.js';
+import { MeasurementsBatcher } from './measurements-batcher.js';
+import { EventsReporter } from './reporting/events-reporter.js';
+import { GqlDataSender } from './reporting/gql-data-sender.js';
+import { MeasurementsReporter } from './reporting/measurements-reporter.js';
+import './reporting/types.js';
+import { ViewportVisibilityTracker } from './viewport-visibility-tracker.js';
+
+class AnalyticsCollectorContainer {
+    _eventsReporter;
+    _measurementsReporter;
+    _appearanceEventsTracker;
+    _measurementsBatcher;
+    _isInitialized = false;
+    initialize(options) {
+        const gqlDataSender = new GqlDataSender(options.gqlDataSenderOptions);
+        const viewportVisibilityTracker = new ViewportVisibilityTracker();
+        this._eventsReporter = new EventsReporter(gqlDataSender, options.schema, options.metadata);
+        this._measurementsReporter = new MeasurementsReporter(gqlDataSender, options.schema, options.metadata);
+        this._appearanceEventsTracker = new AppearanceEventsTracker(viewportVisibilityTracker, this._eventsReporter);
+        this._measurementsBatcher = new MeasurementsBatcher(this._measurementsReporter);
+        this._isInitialized = true;
+    }
+    get eventsReporter() {
+        this.assertInitialized();
+        return this._eventsReporter;
+    }
+    get measurementsReporter() {
+        this.assertInitialized();
+        return this._measurementsReporter;
+    }
+    get appearanceEventsTracker() {
+        this.assertInitialized();
+        return this._appearanceEventsTracker;
+    }
+    get measurementsBatcher() {
+        this.assertInitialized();
+        return this._measurementsBatcher;
+    }
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    assertInitialized() {
+        if (!this._isInitialized) {
+            throw new Error('AnalyticsCollector is not initialized. Call AnalyticsCollector.initialize() first.');
+        }
+    }
+}
+const AnalyticsCollector = new AnalyticsCollectorContainer();
+
+export { AnalyticsCollector };

package/dist/{analytics/app-events-tracker.d.ts → app-events-tracker.d.ts}

@@ -241,3 +241,40 @@ export declare class AppEventsTracker {
     private static saveAppEvent;
     private static queryGql;
 }
+export declare enum AppEventType {
+    AdClick = "AD_CLICK",
+    AdImpression = "AD_IMPRESSION",
+    CommunityMessageView = "COMMUNITY_MESSAGE_VIEW",
+    ContributionCreated = "CONTRIBUTION_CREATED",
+    PostView = "POST_VIEW",
+    ShortVideoImpression = "SHORT_VIDEO_IMPRESSION",
+    ShortVideoProductAddToCart = "SHORT_VIDEO_PRODUCT_ADD_TO_CART",
+    ShortVideoProductCheckout = "SHORT_VIDEO_PRODUCT_CHECKOUT",
+    ShortVideoProductClick = "SHORT_VIDEO_PRODUCT_CLICK",
+    ShortVideoProductImpression = "SHORT_VIDEO_PRODUCT_IMPRESSION",
+    ShortVideoView = "SHORT_VIDEO_VIEW",
+    StreamEngagementTime = "STREAM_ENGAGEMENT_TIME",
+    StreamPageView = "STREAM_PAGE_VIEW",
+    StreamProductAddToCart = "STREAM_PRODUCT_ADD_TO_CART",
+    StreamProductCheckout = "STREAM_PRODUCT_CHECKOUT",
+    StreamProductClick = "STREAM_PRODUCT_CLICK",
+    StreamProductImpression = "STREAM_PRODUCT_IMPRESSION",
+    StreamScrollDepth = "STREAM_SCROLL_DEPTH",
+    StreamTileClick = "STREAM_TILE_CLICK",
+    StreamTileImpression = "STREAM_TILE_IMPRESSION",
+    StreamView = "STREAM_VIEW"
+}
+export declare enum CommunityMessageStatus {
+    Sent = "SENT",
+    Delivered = "DELIVERED",
+    Read = "READ",
+    Failed = "FAILED"
+}
+export type TrackAppEventInput = {
+    eventType: AppEventType;
+    targetId: string;
+    ownerId?: string;
+    value?: number;
+    organizationId?: string;
+    profileId?: string;
+};

package/dist/appearance-events-tracker.d.ts

@@ -0,0 +1,14 @@
+import { type EventsReporter, type Entity, type EntityRelation } from './reporting';
+import type { ViewportVisibilityTracker } from './viewport-visibility-tracker';
+export type TrackingEntityElement = {
+    element: HTMLElement;
+    entity: Entity;
+    relatedEntities?: EntityRelation[] | null;
+};
+export declare class AppearanceEventsTracker {
+    private viewportVisibilityTracker;
+    private eventsReporter;
+    constructor(viewportVisibilityTracker: ViewportVisibilityTracker, eventsReporter: EventsReporter);
+    trackElementAppearance({ entity, element, relatedEntities }: TrackingEntityElement): () => void;
+    untrackElementAppearance(el: HTMLElement): void;
+}

package/dist/appearance-events-tracker.js

@@ -0,0 +1,26 @@
+import { EventType } from './reporting/types.js';
+
+class AppearanceEventsTracker {
+    viewportVisibilityTracker;
+    eventsReporter;
+    constructor(viewportVisibilityTracker, eventsReporter) {
+        this.viewportVisibilityTracker = viewportVisibilityTracker;
+        this.eventsReporter = eventsReporter;
+    }
+    trackElementAppearance({ entity, element, relatedEntities }) {
+        this.viewportVisibilityTracker.registerElement(element, getTrackingId(entity), () => this.eventsReporter.reportEvent({
+            entity,
+            eventType: EventType.Appeared,
+            relatedEntities
+        }));
+        return () => this.viewportVisibilityTracker.unregisterElement(element);
+    }
+    untrackElementAppearance(el) {
+        this.viewportVisibilityTracker.unregisterElement(el);
+    }
+}
+function getTrackingId(entity) {
+    return `${entity.type}::${entity.id}`;
+}
+
+export { AppearanceEventsTracker };

package/dist/contained-entity-measurements-tracker.d.ts

@@ -0,0 +1,15 @@
+import { type Entity, type MeasurementsReporter, type MeasurementType } from './reporting';
+export type TrackingMeasurement = {
+    entity: Entity;
+    measurementType: MeasurementType;
+    value: number;
+};
+export declare class ContainedEntityMeasurementsTracker {
+    private measurementsReporter;
+    private containerEntities;
+    constructor(measurementsReporter: MeasurementsReporter);
+    collectEntityMeasurement(containers: Entity[], measurement: TrackingMeasurement): void;
+    reportGroupedMeasurements(containers: Entity[], onReported?: (measurement: TrackingMeasurement) => void): Promise<void>;
+    clearContainerEntities(containers: Entity[]): void;
+    reset(): void;
+}

package/dist/contained-entity-measurements-tracker.js

@@ -0,0 +1,78 @@
+import { EntityRelationType } from './reporting/types.js';
+
+class ContainedEntityMeasurementsTracker {
+    measurementsReporter;
+    containerEntities = new Map();
+    constructor(measurementsReporter) {
+        this.measurementsReporter = measurementsReporter;
+    }
+    collectEntityMeasurement(containers, measurement) {
+        if (containers.length === 0) {
+            throw new Error('At least one container entity is required.');
+        }
+        const groupKey = getContainerGroupKey(containers);
+        let entitiesInGroup = this.containerEntities.get(groupKey);
+        if (!entitiesInGroup) {
+            entitiesInGroup = new Map();
+            this.containerEntities.set(groupKey, entitiesInGroup);
+        }
+        entitiesInGroup.set(getMeasurementKey(measurement), measurement);
+    }
+    async reportGroupedMeasurements(containers, onReported) {
+        if (containers.length === 0) {
+            throw new Error('At least one container entity is required.');
+        }
+        const groupKey = getContainerGroupKey(containers);
+        const entitiesInGroup = this.containerEntities.get(groupKey);
+        if (!entitiesInGroup || entitiesInGroup.size === 0) {
+            return;
+        }
+        const containerRelations = getContainerRelations(containers);
+        try {
+            await Promise.all(Array.from(entitiesInGroup.values()).map(async (measurement) => {
+                await this.measurementsReporter.reportMeasurement({
+                    entity: measurement.entity,
+                    measurementType: measurement.measurementType,
+                    value: measurement.value,
+                    relatedEntities: containerRelations,
+                });
+                onReported?.(measurement);
+            }));
+        }
+        finally {
+            this.containerEntities.delete(groupKey);
+        }
+    }
+    clearContainerEntities(containers) {
+        const groupKey = getContainerGroupKey(containers);
+        this.containerEntities.delete(groupKey);
+    }
+    reset() {
+        this.containerEntities.clear();
+    }
+}
+function getEntityKey(entity) {
+    return `${entity.type}::${entity.id}`;
+}
+function getMeasurementKey(container) {
+    return `${getEntityKey(container.entity)}::${container.measurementType}`;
+}
+function normalizeContainers(containers) {
+    const uniq = new Map();
+    for (const c of containers) {
+        uniq.set(getEntityKey(c), c);
+    }
+    return Array.from(uniq.values()).sort((a, b) => getEntityKey(a).localeCompare(getEntityKey(b)));
+}
+function getContainerGroupKey(containers) {
+    const keys = normalizeContainers(containers).map(getEntityKey);
+    return keys.join('||');
+}
+function getContainerRelations(containers) {
+    return normalizeContainers(containers).map((c) => ({
+        relationType: EntityRelationType.PlacedIn,
+        entity: c,
+    }));
+}
+
+export { ContainedEntityMeasurementsTracker };

package/dist/events-reporter.d.ts

@@ -0,0 +1,14 @@
+import { type AnalyticsMetadata, type EntityType, type EventType, type EntityRelation } from './types';
+import type { GqlDataSender } from './gql-data-sender';
+export type ReportedEvent = {
+    entityType: EntityType;
+    entityId: string;
+    eventType: EventType;
+    relatedEntities?: EntityRelation[] | null;
+};
+export declare class EventsReporter {
+    private gqlDataSender;
+    private analyticsMetadata?;
+    constructor(gqlDataSender: GqlDataSender, analyticsMetadata?: AnalyticsMetadata | null);
+    reportEvent({ entityType, entityId, eventType, relatedEntities }: ReportedEvent): Promise<void>;
+}

package/dist/events-reporter.js

@@ -0,0 +1,27 @@
+import { ApiMode } from './types.js';
+import ReportEvent from './report-event.graphql.js';
+import ReportExternalEvent from './report-external-event.graphql.js';
+
+class EventsReporter {
+    gqlDataSender;
+    analyticsMetadata;
+    constructor(gqlDataSender, analyticsMetadata) {
+        this.gqlDataSender = gqlDataSender;
+        this.analyticsMetadata = analyticsMetadata;
+    }
+    async reportEvent({ entityType, entityId, eventType, relatedEntities }) {
+        const input = {
+            entityType,
+            entityId,
+            eventType,
+            relatedEntities,
+            installation: this.analyticsMetadata?.installationId
+                ? {
+                    id: this.analyticsMetadata.installationId,
+                } : null
+        };
+        await this.gqlDataSender.send((apiMode) => apiMode === ApiMode.Internal ? ReportEvent : ReportExternalEvent, { input });
+    }
+}
+
+export { EventsReporter };

package/dist/gql-data-sender.d.ts

@@ -0,0 +1,16 @@
+import type { Client } from '@urql/core';
+import type { ApiMode } from './types';
+export type GqlDataSenderOptions = {
+    client: Client;
+    mode: ApiMode;
+} | {
+    endpoint: string;
+    mode: ApiMode;
+};
+export declare class GqlDataSender {
+    private gqlEndpoint;
+    private client;
+    private apiMode;
+    constructor(options: GqlDataSenderOptions);
+    send(querySelector: (apiMode: ApiMode) => string, variables?: object): Promise<void>;
+}

package/dist/gql-data-sender.js

@@ -0,0 +1,38 @@
+class GqlDataSender {
+    gqlEndpoint = null;
+    client = null;
+    apiMode;
+    constructor(options) {
+        if ('client' in options) {
+            this.client = options.client;
+            this.gqlEndpoint = null;
+        }
+        else {
+            this.gqlEndpoint = options.endpoint;
+            this.client = null;
+        }
+        this.apiMode = options.mode;
+    }
+    async send(querySelector, variables) {
+        const query = querySelector(this.apiMode);
+        if (this.gqlEndpoint) {
+            await sendGqlBeacon(this.gqlEndpoint, query, variables);
+        }
+        else if (this.client) {
+            await this.client.mutation(query, variables).toPromise();
+        }
+        else {
+            console.error('EventsReporter not properly initialized.');
+        }
+    }
+}
+async function sendGqlBeacon(endpoint, query, variables) {
+    const body = JSON.stringify({ query, variables });
+    const blob = new Blob([body], { type: 'application/json' });
+    const accepted = navigator.sendBeacon(endpoint, blob);
+    if (!accepted) {
+        throw new Error('Failed to queue analytics beacon.');
+    }
+}
+
+export { GqlDataSender };

package/dist/graphql/report-event.graphql.js

@@ -0,0 +1,3 @@
+var ReportEvent = "mutation ReportEvent($input: ReportEventInput!) {\n  reportEvent(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportEvent as default };

package/dist/graphql/report-external-event.graphql.js

@@ -0,0 +1,3 @@
+var ReportExternalEvent = "mutation ReportExternalEvent($input: ReportExternalEventInput!) {\n  reportExternalEvent(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportExternalEvent as default };

package/dist/graphql/report-external-measurement.graphql.js

@@ -0,0 +1,3 @@
+var ReportExternalMeasurement = "mutation ReportExternalMeasurement($input: ReportExternalMeasurementInput!) {\n  reportExternalMeasurement(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportExternalMeasurement as default };

package/dist/graphql/report-measurement.graphql.js

@@ -0,0 +1,3 @@
+var ReportMeasurement = "mutation ReportMeasurement($input: ReportMeasurementInput!) {\n  reportMeasurement(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportMeasurement as default };

package/dist/index.d.ts

@@ -1,2 +1,6 @@
-export * as Types from "./types";
-export { AppEventsTracker, AppEventType, CommunityMessageStatus, } from "./analytics";
+export { EntityRelationType, EntityType, EventType, MeasurementType, type AnalyticsMetadata, type AnalyticsSchema, type Entity, type EntityRelation, } from './reporting/types';
+export { type AnalyticsCollectorInitOptions, AnalyticsCollector } from './analytics-collector';
+export { type TrackingEntityElement, AppearanceEventsTracker } from './appearance-events-tracker';
+export { ViewportVisibilityTracker } from './viewport-visibility-tracker';
+export { type BatchedMeasurement, type MeasurementsBatchReportResult, type FailedBatchedMeasurement, MeasurementsBatcher, } from './measurements-batcher';
+export { Schemas } from './schemas';

package/dist/index.js

@@ -1,4 +1,6 @@
-import * as types from './types.js';
-export { types as Types };
-export { AppEventsTracker } from './analytics/app-events-tracker.js';
-export { AppEventType, CommunityMessageStatus } from './analytics/types.js';
+export { EntityRelationType, EntityType, EventType, MeasurementType } from './reporting/types.js';
+export { AnalyticsCollector } from './analytics-collector.js';
+export { AppearanceEventsTracker } from './appearance-events-tracker.js';
+export { ViewportVisibilityTracker } from './viewport-visibility-tracker.js';
+export { MeasurementsBatcher } from './measurements-batcher.js';
+export { Schemas } from './schemas.js';

package/dist/measurements-batcher.d.ts

@@ -0,0 +1,23 @@
+import { type Entity, type MeasurementsReporter, type MeasurementType } from './reporting';
+export type BatchedMeasurement = {
+    entity: Entity;
+    measurementType: MeasurementType;
+    value: number;
+};
+export type FailedBatchedMeasurement = {
+    measurement: BatchedMeasurement;
+    error: unknown;
+};
+export type MeasurementsBatchReportResult = {
+    succeeded: BatchedMeasurement[];
+    failed: FailedBatchedMeasurement[];
+};
+export declare class MeasurementsBatcher {
+    private measurementsReporter;
+    private containerEntities;
+    constructor(measurementsReporter: MeasurementsReporter);
+    collect(containers: Entity[], measurement: BatchedMeasurement): void;
+    reportBatch(containers: Entity[]): Promise<MeasurementsBatchReportResult>;
+    clearBatch(containers: Entity[]): void;
+    reset(): void;
+}

package/dist/measurements-batcher.js

@@ -0,0 +1,90 @@
+import { EntityRelationType } from './reporting/types.js';
+
+class MeasurementsBatcher {
+    measurementsReporter;
+    containerEntities = new Map();
+    constructor(measurementsReporter) {
+        this.measurementsReporter = measurementsReporter;
+    }
+    collect(containers, measurement) {
+        if (containers.length === 0) {
+            throw new Error('At least one container entity is required.');
+        }
+        const groupKey = getContainerGroupKey(containers);
+        let entitiesInGroup = this.containerEntities.get(groupKey);
+        if (!entitiesInGroup) {
+            entitiesInGroup = new Map();
+            this.containerEntities.set(groupKey, entitiesInGroup);
+        }
+        entitiesInGroup.set(getMeasurementKey(measurement), measurement);
+    }
+    async reportBatch(containers) {
+        if (containers.length === 0) {
+            throw new Error('At least one container entity is required.');
+        }
+        const groupKey = getContainerGroupKey(containers);
+        const entitiesInGroup = this.containerEntities.get(groupKey);
+        if (!entitiesInGroup || entitiesInGroup.size === 0) {
+            return { succeeded: [], failed: [] };
+        }
+        const containerRelations = getContainerRelations(containers);
+        const entries = Array.from(entitiesInGroup.entries());
+        const succeeded = [];
+        const failed = [];
+        await Promise.all(entries.map(async ([key, measurement]) => {
+            try {
+                await this.measurementsReporter.reportMeasurement({
+                    entity: measurement.entity,
+                    measurementType: measurement.measurementType,
+                    value: measurement.value,
+                    relatedEntities: containerRelations,
+                });
+                succeeded.push(measurement);
+                entitiesInGroup.delete(key);
+            }
+            catch (error) {
+                failed.push({ measurement, error });
+            }
+        }));
+        if (entitiesInGroup.size === 0) {
+            this.containerEntities.delete(groupKey);
+        }
+        return { succeeded, failed };
+    }
+    clearBatch(containers) {
+        const groupKey = getContainerGroupKey(containers);
+        this.containerEntities.delete(groupKey);
+    }
+    reset() {
+        this.containerEntities.clear();
+    }
+}
+function getEntityKey(entity) {
+    return `${entity.type}::${entity.id}`;
+}
+function getMeasurementKey(container) {
+    return `${getEntityKey(container.entity)}::${container.measurementType}`;
+}
+function normalizeContainers(containers) {
+    const uniq = new Map();
+    for (const c of containers) {
+        uniq.set(getEntityKey(c), c);
+    }
+    return Array.from(uniq.values()).sort((a, b) => {
+        const ka = getEntityKey(a);
+        const kb = getEntityKey(b);
+        return ka < kb ? -1 : ka > kb ? 1 : 0;
+    });
+}
+function getContainerGroupKey(containers) {
+    const keys = normalizeContainers(containers).map(getEntityKey);
+    return keys.join('||');
+}
+function getContainerRelations(containers) {
+    return normalizeContainers(containers).map((c) => ({
+        relationType: EntityRelationType.PlacedIn,
+        entity: c,
+    }));
+}
+
+export { MeasurementsBatcher };

package/dist/measurements-reporter.d.ts

@@ -0,0 +1,15 @@
+import { type AnalyticsMetadata, type EntityType, type MeasurementType, type EntityRelation } from './types';
+import type { GqlDataSender } from './gql-data-sender';
+export type ReportedMeasurement = {
+    entityType: EntityType;
+    entityId: string;
+    measurementType: MeasurementType;
+    value: number;
+    relatedEntities?: EntityRelation[] | null;
+};
+export declare class MeasurementsReporter {
+    private gqlDataSender;
+    private analyticsMetadata?;
+    constructor(gqlDataSender: GqlDataSender, analyticsMetadata?: AnalyticsMetadata | null);
+    reportMeasurement({ entityType, entityId, measurementType, value, relatedEntities }: ReportedMeasurement): Promise<void>;
+}

package/dist/measurements-reporter.js

@@ -0,0 +1,28 @@
+import { ApiMode } from './types.js';
+import ReportMeasurement from './report-measurement.graphql.js';
+import ReportExternalMeasurement from './report-external-measurement.graphql.js';
+
+class MeasurementsReporter {
+    gqlDataSender;
+    analyticsMetadata;
+    constructor(gqlDataSender, analyticsMetadata) {
+        this.gqlDataSender = gqlDataSender;
+        this.analyticsMetadata = analyticsMetadata;
+    }
+    async reportMeasurement({ entityType, entityId, measurementType, value, relatedEntities }) {
+        const input = {
+            entityType,
+            entityId,
+            measurementType,
+            value,
+            relatedEntities,
+            installation: this.analyticsMetadata?.installationId
+                ? {
+                    id: this.analyticsMetadata.installationId,
+                } : null,
+        };
+        await this.gqlDataSender.send((apiMode) => apiMode === ApiMode.Internal ? ReportMeasurement : ReportExternalMeasurement, { input });
+    }
+}
+
+export { MeasurementsReporter };

package/dist/report-event.graphql.js

@@ -0,0 +1,3 @@
+var ReportEvent = "mutation ReportEvent($input: ReportEventInput!) {\n  reportEvent(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportEvent as default };

package/dist/report-external-event.graphql.js

@@ -0,0 +1,3 @@
+var ReportExternalEvent = "mutation ReportExternalEvent($input: ReportExternalEventInput!) {\n  reportExternalEvent(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportExternalEvent as default };

package/dist/report-external-measurement.graphql.js

@@ -0,0 +1,3 @@
+var ReportExternalMeasurement = "mutation ReportExternalMeasurement($input: ReportExternalMeasurementInput!) {\n  reportExternalMeasurement(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportExternalMeasurement as default };

package/dist/report-measurement.graphql.js

@@ -0,0 +1,3 @@
+var ReportMeasurement = "mutation ReportMeasurement($input: ReportMeasurementInput!) {\n  reportMeasurement(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportMeasurement as default };

package/dist/reporting/events-reporter.d.ts

@@ -0,0 +1,14 @@
+import type { AnalyticsSchema, AnalyticsMetadata, EventType, EntityRelation, Entity } from './types';
+import type { GqlDataSender } from './gql-data-sender';
+export type ReportedEvent = {
+    entity: Entity;
+    eventType: EventType;
+    relatedEntities?: EntityRelation[] | null;
+};
+export declare class EventsReporter {
+    private gqlDataSender;
+    private analyticsSchema;
+    private analyticsMetadata?;
+    constructor(gqlDataSender: GqlDataSender, analyticsSchema: AnalyticsSchema, analyticsMetadata?: AnalyticsMetadata | null);
+    reportEvent({ entity, eventType, relatedEntities }: ReportedEvent): Promise<void>;
+}

package/dist/reporting/events-reporter.js

@@ -0,0 +1,30 @@
+class EventsReporter {
+    gqlDataSender;
+    analyticsSchema;
+    analyticsMetadata;
+    constructor(gqlDataSender, analyticsSchema, analyticsMetadata) {
+        this.gqlDataSender = gqlDataSender;
+        this.analyticsSchema = analyticsSchema;
+        this.analyticsMetadata = analyticsMetadata;
+    }
+    async reportEvent({ entity, eventType, relatedEntities }) {
+        const input = {
+            entityType: entity.type,
+            entityId: entity.id,
+            eventType,
+            relatedEntities: relatedEntities
+                ?.map(({ relationType, entity }) => ({
+                relationType,
+                entityType: entity.type,
+                entityId: entity.id,
+            })) ?? null,
+            installation: this.analyticsMetadata?.installationId
+                ? {
+                    id: this.analyticsMetadata.installationId,
+                } : null,
+        };
+        await this.gqlDataSender.send(this.analyticsSchema.reportEvent, { input });
+    }
+}
+
+export { EventsReporter };

package/dist/reporting/gql-data-sender.d.ts

@@ -0,0 +1,12 @@
+import type { Client } from '@urql/core';
+export type GqlDataSenderOptions = {
+    client: Client;
+} | {
+    endpoint: string;
+};
+export declare class GqlDataSender {
+    private gqlEndpoint;
+    private client;
+    constructor(options: GqlDataSenderOptions);
+    send(query: string, variables?: object): Promise<void>;
+}