@acorex-platform/module-activity-insight-client 0.0.20

package/types/acorex-platform-module-activity-insight-client-contracts.d.ts

@@ -0,0 +1,398 @@
+declare const AXMActivityInsightMenuKeys: {
+    readonly ActivityInsight: {
+        readonly Root: "ActivityInsight:Menu:Root";
+        readonly Events: "ActivityInsight:Menu:Events";
+        readonly Timelines: "ActivityInsight:Menu:Timelines";
+        readonly Policies: "ActivityInsight:Menu:Policies";
+    };
+};
+
+/**
+ * Insights & Reporting capabilities used by this module.
+ * Domain capability keys for this module. Root groups live in `AXPCommonPermissionGroupKeys` (common contracts).
+ */
+declare const AXPInsightsReportingPermissionKeys: {
+    readonly Access: "InsightsReporting:Permission:Access";
+    readonly MaintainReports: "InsightsReporting:Permission:MaintainReports";
+    readonly MaintainData: "InsightsReporting:Permission:MaintainData";
+    readonly ViewActivityInsight: "InsightsReporting:Permission:ViewActivityInsight";
+    readonly ManageActivityInsight: "InsightsReporting:Permission:ManageActivityInsight";
+    readonly Setup: "InsightsReporting:Permission:Setup";
+};
+/**
+ * @deprecated Prefer {@link AXPInsightsReportingPermissionKeys}.
+ * Legacy nested shape kept so existing imports compile during migration.
+ */
+declare const AXMActivityInsightPermissionKeys: {
+    readonly ActivityInsight: {
+        readonly Events: {
+            readonly View: "InsightsReporting:Permission:ViewActivityInsight";
+        };
+        readonly Timelines: {
+            readonly View: "InsightsReporting:Permission:ViewActivityInsight";
+        };
+        readonly Policies: {
+            readonly Manage: "InsightsReporting:Permission:ManageActivityInsight";
+        };
+        readonly Admin: "InsightsReporting:Permission:ManageActivityInsight";
+        readonly Management: "InsightsReporting:Permission:ManageActivityInsight";
+    };
+};
+
+declare enum AXPActivityInsightSettings {
+    Enabled = "ActivityInsight:Setting:Tracking.Enabled",
+    FlushIntervalMs = "ActivityInsight:Setting:Buffer.FlushIntervalMs",
+    MaxBatchSize = "ActivityInsight:Setting:Buffer.MaxBatchSize",
+    MaxPayloadBytes = "ActivityInsight:Setting:Buffer.MaxPayloadBytes",
+    MaxQueueSize = "ActivityInsight:Setting:Buffer.MaxQueueSize",
+    FlushOnVisibilityHidden = "ActivityInsight:Setting:Buffer.FlushOnVisibilityHidden",
+    UseBeaconForFinalFlush = "ActivityInsight:Setting:Buffer.UseBeaconForFinalFlush",
+    MaskingEnabled = "ActivityInsight:Setting:Privacy.MaskingEnabled",
+    SamplingEnabled = "ActivityInsight:Setting:Privacy.SamplingEnabled",
+    TrackAiContent = "ActivityInsight:Setting:Privacy.TrackAiContent"
+}
+
+declare const AXMActivityInsightQueryKeys: {
+    readonly ActivityEvent: {
+        readonly List: "ActivityInsight:ActivityEvent:List";
+        readonly GetOne: "ActivityInsight:ActivityEvent:GetOne";
+        readonly Aggregate: "ActivityInsight:ActivityEvent:Aggregate";
+    };
+    readonly ActivityTimeline: {
+        readonly Session: "ActivityInsight:ActivityTimeline:Session";
+        readonly Journey: "ActivityInsight:ActivityTimeline:Journey";
+        readonly Entity: "ActivityInsight:ActivityTimeline:Entity";
+    };
+};
+
+declare const AXMActivityInsightCommandKeys: {
+    readonly ActivityEvent: {
+        readonly Export: "ActivityInsight:ActivityEvent:Export";
+    };
+};
+
+declare const AXMActivityInsightTransportKeys: {
+    readonly Event: {
+        readonly BulkIngest: "ActivityInsight:Event:BulkIngest";
+    };
+};
+
+type AXMActivityEventType = 'action' | 'view' | 'system' | 'error';
+type AXMActivityCategory = 'navigation' | 'entity' | 'command' | 'query' | 'form' | 'ai' | 'workflow' | 'security' | 'error' | 'custom';
+type AXMActivityEventStatus = 'started' | 'completed' | 'failed' | 'cancelled' | 'abandoned';
+type AXMActivityEventSeverity = 'low' | 'normal' | 'high' | 'critical';
+type AXMActivityEventPriority = 'low' | 'normal' | 'high';
+type AXMActivityEventSource = 'frontend' | 'backend';
+interface AXMActivityEvent {
+    id: string;
+    name: string;
+    type: AXMActivityEventType;
+    category: AXMActivityCategory;
+    timestamp: string;
+    sessionId: string;
+    journeyId?: string;
+    parentActivityId?: string;
+    userId?: string;
+    username?: string;
+    tenantId?: string;
+    applicationId?: string;
+    requestId?: string;
+    traceId?: string;
+    source: AXMActivityEventSource;
+    route?: string;
+    module?: string;
+    entityName?: string;
+    entityId?: string;
+    viewId?: string;
+    widgetId?: string;
+    commandName?: string;
+    queryName?: string;
+    workflowId?: string;
+    aiConversationId?: string;
+    status?: AXMActivityEventStatus;
+    durationMs?: number;
+    severity?: AXMActivityEventSeverity;
+    priority?: AXMActivityEventPriority;
+    properties?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+interface AXMActivityBatch {
+    batchId: string;
+    sentAt: string;
+    events: AXMActivityEvent[];
+}
+interface AXMActivitySession {
+    id: string;
+    userId?: string;
+    tenantId?: string;
+    applicationId?: string;
+    startedAt: string;
+    endedAt?: string;
+}
+interface AXMActivityJourney {
+    id: string;
+    name: string;
+    sessionId: string;
+    startedAt: string;
+    endedAt?: string;
+    status?: AXMActivityEventStatus;
+    result?: Record<string, unknown>;
+}
+interface AXMActivityStep {
+    activityId: string;
+    name: string;
+    timestamp: string;
+    durationMs?: number;
+    status?: AXMActivityEventStatus;
+}
+
+interface ActivityInsightScopeContext {
+    tenantId: string;
+    userId?: string;
+    applicationId?: string;
+}
+interface ActivityInsightPagedResult<T> {
+    items: T[];
+    total: number;
+    skip?: number;
+    take?: number;
+}
+interface ActivityIngestResultDto {
+    accepted: number;
+    rejected: number;
+    errors: Array<{
+        index: number;
+        message: string;
+    }>;
+}
+interface ActivityIngestBulkDto {
+    batchId?: string;
+    sentAt?: string;
+    events: AXMActivityEvent[];
+}
+interface ActivityQueryDto {
+    skip?: number;
+    take?: number;
+    userId?: string;
+    sessionId?: string;
+    journeyId?: string;
+    entityName?: string;
+    entityId?: string;
+    commandName?: string;
+    queryName?: string;
+    requestId?: string;
+    traceId?: string;
+    category?: string;
+    name?: string;
+    from?: string;
+    to?: string;
+}
+interface ActivityAggregateQueryDto extends ActivityQueryDto {
+    groupBy?: Array<'module' | 'entityName' | 'name' | 'userId' | 'category'>;
+    interval?: string;
+}
+interface ActivityAggregateBucketDto {
+    key: Record<string, string>;
+    count: number;
+}
+interface ActivityTimelineDto {
+    id: string;
+    title: string;
+    steps: ActivityTimelineStepDto[];
+}
+interface ActivityTimelineStepDto {
+    activityId: string;
+    name: string;
+    timestamp: string;
+    durationMs?: number;
+    status?: string;
+    category?: string;
+    properties?: Record<string, unknown>;
+}
+
+declare const RootConfig: {
+    readonly config: {
+        i18n: string;
+    };
+    readonly module: {
+        readonly route: "activity-insight";
+        readonly module: "ActivityInsight";
+        readonly name: "ActivityInsight";
+        readonly title: "@activity-insight:module.title";
+        readonly icon: "fa-light fa-chart-network";
+    };
+    readonly entities: {
+        readonly activityEvent: {
+            readonly name: "ActivityEvent";
+            readonly title: "@activity-insight:entities.activity-event.title";
+            readonly titlePlural: "@activity-insight:entities.activity-event.plural";
+            readonly icon: "fa-light fa-wave-pulse";
+        };
+        readonly trackingRule: {
+            readonly name: "TrackingRule";
+            readonly title: "@activity-insight:entities.tracking-rule.title";
+            readonly titlePlural: "@activity-insight:entities.tracking-rule.plural";
+            readonly icon: "fa-light fa-sliders";
+        };
+        readonly activitySavedView: {
+            readonly name: "ActivitySavedView";
+            readonly title: "@activity-insight:entities.saved-view.title";
+            readonly titlePlural: "@activity-insight:entities.saved-view.plural";
+            readonly icon: "fa-light fa-bookmark";
+        };
+        readonly retentionPolicy: {
+            readonly name: "RetentionPolicy";
+            readonly title: "@activity-insight:entities.retention-policy.title";
+            readonly titlePlural: "@activity-insight:entities.retention-policy.plural";
+            readonly icon: "fa-light fa-calendar-clock";
+        };
+        readonly maskingPolicy: {
+            readonly name: "MaskingPolicy";
+            readonly title: "@activity-insight:entities.masking-policy.title";
+            readonly titlePlural: "@activity-insight:entities.masking-policy.plural";
+            readonly icon: "fa-light fa-eye-slash";
+        };
+        readonly samplingPolicy: {
+            readonly name: "SamplingPolicy";
+            readonly title: "@activity-insight:entities.sampling-policy.title";
+            readonly titlePlural: "@activity-insight:entities.sampling-policy.plural";
+            readonly icon: "fa-light fa-percent";
+        };
+        readonly activityDataSource: {
+            readonly name: "ActivityDataSource";
+            readonly title: "@activity-insight:entities.data-source.title";
+            readonly titlePlural: "@activity-insight:entities.data-source.plural";
+            readonly icon: "fa-light fa-database";
+        };
+    };
+};
+
+declare const AXMActivityEventNames: {
+    readonly Page: {
+        readonly Viewed: "page.viewed";
+    };
+    readonly Entity: {
+        readonly ListOpened: "entity.list.opened";
+        readonly DetailOpened: "entity.detail.opened";
+        readonly FilterApplied: "entity.filter.applied";
+        readonly SearchApplied: "entity.search.applied";
+        readonly SortApplied: "entity.sort.applied";
+        readonly Created: "entity.created";
+        readonly Updated: "entity.updated";
+        readonly Deleted: "entity.deleted";
+    };
+    readonly Command: {
+        readonly Executed: "command.executed";
+    };
+    readonly Query: {
+        readonly Executed: "query.executed";
+    };
+    readonly Form: {
+        readonly Submitted: "form.submitted";
+        readonly ValidationFailed: "form.validation.failed";
+        readonly FieldChanged: "form.field.changed";
+    };
+    readonly Ai: {
+        readonly ChatStarted: "ai.chat.started";
+        readonly MessageSent: "ai.message.sent";
+        readonly GenerationStarted: "ai.generation.started";
+        readonly GenerationCompleted: "ai.generation.completed";
+        readonly GenerationStopped: "ai.generation.stopped";
+        readonly ImageGenerated: "ai.image.generated";
+    };
+    readonly Workflow: {
+        readonly ActionOpened: "workflow.action.opened";
+        readonly StepTransitioned: "workflow.step.transitioned";
+    };
+    readonly Security: {
+        readonly PermissionAdded: "security.permission.added";
+        readonly RoleUpdated: "security.role.updated";
+    };
+    readonly Error: {
+        readonly Seen: "error.seen";
+    };
+    readonly Process: {
+        readonly Abandoned: "process.abandoned";
+    };
+};
+
+interface AXMActivityTrackingPolicy {
+    enabled?: boolean;
+    list?: {
+        open?: boolean;
+        filterApply?: boolean;
+        search?: boolean;
+        sort?: boolean;
+        export?: boolean;
+    };
+    detail?: {
+        open?: boolean;
+        tabChange?: boolean;
+    };
+    form?: {
+        createStart?: boolean;
+        updateStart?: boolean;
+        submit?: boolean;
+        validationError?: boolean;
+        fieldChange?: {
+            enabled?: boolean;
+            include?: string[];
+            exclude?: string[];
+        };
+    };
+    commands?: Record<string, boolean | {
+        enabled?: boolean;
+        severity?: AXMActivityEventSeverity;
+    }>;
+    queries?: Record<string, boolean>;
+    masking?: {
+        fields?: string[];
+    };
+    sampling?: Record<string, number>;
+}
+interface AXMActivityMaskingPolicy {
+    enabled?: boolean;
+    denylist?: string[];
+    allowlist?: string[];
+    maxPropertyBytes?: number;
+}
+interface AXMActivitySamplingPolicy {
+    rates?: Record<string, number>;
+    defaultRate?: number;
+}
+interface AXMActivityRetentionPolicy {
+    enabled?: boolean;
+    periodDays?: number;
+}
+interface AXMActivityProviderConfig {
+    provider: 'noop' | 'console' | 'in-memory' | 'elasticsearch' | 'clickhouse' | 'posthog' | 'matomo' | 'custom-rest';
+    options?: Record<string, unknown>;
+}
+interface AXMActivityBufferConfig {
+    flushIntervalMs: number;
+    maxBatchSize: number;
+    maxPayloadBytes: number;
+    finalFlushMaxBytes: number;
+    maxQueueSize: number;
+    retryLimit: number;
+    retryBackoffMs: number;
+    maxPropertyBytes: number;
+    flushOnVisibilityHidden: boolean;
+    useBeaconForFinalFlush: boolean;
+}
+declare const AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG: AXMActivityBufferConfig;
+interface AXMActivityTrackingRule {
+    source: string;
+    eventName: string;
+    category?: string;
+    priority?: AXMActivityEventPriority;
+    severity?: AXMActivityEventSeverity;
+    samplingRate?: number;
+}
+
+declare const AXM_DEFAULT_MASKING_DENYLIST: readonly ["password", "token", "secret", "accessToken", "refreshToken", "authorization", "apiKey", "privateKey", "creditCard"];
+declare function maskActivityProperties(value: unknown, policy?: AXMActivityMaskingPolicy, depth?: number): unknown;
+declare function truncateActivityProperties(properties: Record<string, unknown> | undefined, maxBytes: number): Record<string, unknown> | undefined;
+
+export { AXMActivityEventNames, AXMActivityInsightCommandKeys, AXMActivityInsightMenuKeys, AXMActivityInsightPermissionKeys, AXMActivityInsightQueryKeys, AXMActivityInsightTransportKeys, AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG, AXM_DEFAULT_MASKING_DENYLIST, AXPActivityInsightSettings, AXPInsightsReportingPermissionKeys, RootConfig, maskActivityProperties, truncateActivityProperties };
+export type { AXMActivityBatch, AXMActivityBufferConfig, AXMActivityCategory, AXMActivityEvent, AXMActivityEventPriority, AXMActivityEventSeverity, AXMActivityEventSource, AXMActivityEventStatus, AXMActivityEventType, AXMActivityJourney, AXMActivityMaskingPolicy, AXMActivityProviderConfig, AXMActivityRetentionPolicy, AXMActivitySamplingPolicy, AXMActivitySession, AXMActivityStep, AXMActivityTrackingPolicy, AXMActivityTrackingRule, ActivityAggregateBucketDto, ActivityAggregateQueryDto, ActivityIngestBulkDto, ActivityIngestResultDto, ActivityInsightPagedResult, ActivityInsightScopeContext, ActivityQueryDto, ActivityTimelineDto, ActivityTimelineStepDto };

package/types/acorex-platform-module-activity-insight-client.d.ts

@@ -0,0 +1,131 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import * as i1 from '@acorex-platform/framework-client/runtime';
+import * as i2 from '@acorex-platform/framework-client/common';
+import { AXMActivityEvent, AXMActivityJourney, AXMActivityEventStatus, AXMActivityTrackingRule } from '@acorex-platform/module-activity-insight-client/contracts';
+
+declare class AXMActivityInsightModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMActivityInsightModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMActivityInsightModule, never, [typeof i1.AXPRuntimeModule, typeof i2.AXPCommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXMActivityInsightModule>;
+}
+
+interface AXMActivityTrackPayload extends Partial<AXMActivityEvent> {
+    name: string;
+}
+declare class AXMActivityInsightTrackerService {
+    private readonly sessionService;
+    private readonly settingsService;
+    private readonly hooks;
+    private readonly policy;
+    private readonly transport;
+    private readonly journeyService;
+    private readonly router;
+    private readonly destroyRef;
+    private readonly buffer;
+    private flushTimer;
+    private flushTimerStarting;
+    private flushChain;
+    private pendingRetry;
+    private initialized;
+    private visibilityHandlersRegistered;
+    private currentJourneyId;
+    init(): void;
+    track(name: string, payload?: Partial<AXMActivityEvent>): Promise<void>;
+    trackMany(events: AXMActivityTrackPayload[]): Promise<void>;
+    startJourney(name: string): AXMActivityJourney;
+    endJourney(journeyId?: string, status?: AXMActivityEventStatus, result?: Record<string, unknown>): void;
+    startActivity(name: string, properties?: Record<string, unknown>): string;
+    endActivity(activityId: string, status?: AXMActivityEventStatus, properties?: Record<string, unknown>): void;
+    trackPageView(route?: string): void;
+    trackClick(name: string, properties?: Record<string, unknown>): void;
+    trackEntityListOpen(module: string, entityName: string, properties?: Record<string, unknown>): void;
+    trackEntityDetailOpen(module: string, entityName: string, entityId?: string, properties?: Record<string, unknown>): void;
+    trackFilterApply(entityName: string, properties?: Record<string, unknown>): void;
+    trackSearch(entityName: string, properties?: Record<string, unknown>): void;
+    trackSort(entityName: string, properties?: Record<string, unknown>): void;
+    trackCommandExecution(commandName: string, options?: {
+        success?: boolean;
+        durationMs?: number;
+        properties?: Record<string, unknown>;
+    }): void;
+    trackQueryExecution(queryName: string, options?: {
+        success?: boolean;
+        durationMs?: number;
+        properties?: Record<string, unknown>;
+    }): void;
+    trackFormSubmit(entityName: string, properties?: Record<string, unknown>): void;
+    trackValidationError(entityName: string, properties?: Record<string, unknown>): void;
+    trackAiInteraction(name: string, properties?: Record<string, unknown>): void;
+    trackError(error: unknown, properties?: Record<string, unknown>): void;
+    flush(reason?: 'interval' | 'batch-size' | 'manual' | 'visibility' | 'final'): Promise<void>;
+    enable(): void;
+    disable(): void;
+    getSessionId(): string;
+    private canTrack;
+    private onSessionActive;
+    private onSessionInactive;
+    private cancelPendingRetry;
+    private buildEvent;
+    private inferType;
+    private inferCategory;
+    private ensureSessionId;
+    private flushIfNeeded;
+    private startFlushTimer;
+    private stopFlushTimer;
+    private registerVisibilityFlush;
+    private scheduleRetry;
+    private getSetting;
+    private getBufferSetting;
+    private clampBufferNumber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMActivityInsightTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXMActivityInsightTrackerService>;
+}
+
+interface ActiveActivity {
+    id: string;
+    name: string;
+    startedAt: string;
+    parentActivityId?: string;
+    journeyId?: string;
+    properties?: Record<string, unknown>;
+}
+interface ActiveJourney {
+    id: string;
+    name: string;
+    sessionId: string;
+    startedAt: string;
+}
+declare class AXMActivityInsightJourneyService {
+    private readonly activities;
+    private readonly journeys;
+    startJourney(name: string, sessionId: string): AXMActivityJourney;
+    endJourney(journeyId: string, status?: AXMActivityEventStatus, result?: Record<string, unknown>): AXMActivityJourney | null;
+    getActiveJourney(journeyId: string): ActiveJourney | undefined;
+    startActivity(name: string, options?: {
+        parentActivityId?: string;
+        journeyId?: string;
+        properties?: Record<string, unknown>;
+    }): ActiveActivity;
+    endActivity(activityId: string, status?: AXMActivityEventStatus, properties?: Record<string, unknown>): (ActiveActivity & {
+        endedAt: string;
+        status: AXMActivityEventStatus;
+        durationMs: number;
+    }) | null;
+    buildActivityStartedEvent(activity: ActiveActivity, enrich: Partial<AXMActivityEvent>): Partial<AXMActivityEvent>;
+    buildActivityEndedEvent(activity: ActiveActivity & {
+        endedAt: string;
+        status: AXMActivityEventStatus;
+        durationMs: number;
+    }, enrich: Partial<AXMActivityEvent>): Partial<AXMActivityEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMActivityInsightJourneyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXMActivityInsightJourneyService>;
+}
+
+interface AXMActivityTrackingRuleProvider {
+    module: string;
+    rules: AXMActivityTrackingRule[];
+}
+declare const AXM_ACTIVITY_TRACKING_RULE_PROVIDER: InjectionToken<AXMActivityTrackingRuleProvider[]>;
+
+export { AXMActivityInsightJourneyService, AXMActivityInsightModule, AXMActivityInsightTrackerService, AXM_ACTIVITY_TRACKING_RULE_PROVIDER };