@trii/types 2.10.764 → 2.10.766

package/dist/src/Conversations/InboxMongo.d.ts

@@ -0,0 +1,154 @@
+import { ID, InboxViewId } from './Conversation';
+export declare const CONVERSATION_SUBSCRIPTIONS_COLLECTION = "conversation_subscriptions";
+export declare const USER_INBOX_ITEMS_COLLECTION = "user_inbox_items";
+export declare const USER_INBOX_COUNTERS_COLLECTION = "user_inbox_counters";
+export declare const INBOX_PROCESSOR_RECEIPTS_COLLECTION = "inbox_processor_receipts";
+/**
+ * MongoDB indexes for conversation_subscriptions.
+ *
+ * The unique index enforces one current subscription state per
+ * user/conversation. The follower index resolves the active followers that
+ * InboxAudienceResolver receives as input.
+ */
+export declare const CONVERSATION_SUBSCRIPTION_INDEXES: readonly [{
+    readonly name: 'uq_subscription_user_conversation';
+    readonly key: {
+        readonly spaceId: 1;
+        readonly userId: 1;
+        readonly conversationId: 1;
+    };
+    readonly unique: true;
+}, {
+    readonly name: 'ix_subscription_conversation_followers';
+    readonly key: {
+        readonly spaceId: 1;
+        readonly conversationId: 1;
+        readonly status: 1;
+        readonly userId: 1;
+    };
+}];
+/**
+ * MongoDB indexes for user_inbox_items.
+ *
+ * views.viewId is the only array field in each compound index. Do not add
+ * views.visibilityReasons to these indexes: MongoDB compound multikey indexes
+ * must not combine multiple array paths.
+ */
+export declare const USER_INBOX_ITEM_INDEXES: readonly [{
+    readonly name: 'uq_inbox_item_user_conversation';
+    readonly key: {
+        readonly spaceId: 1;
+        readonly userId: 1;
+        readonly conversationId: 1;
+    };
+    readonly unique: true;
+}, {
+    readonly name: 'ix_inbox_view_activity';
+    readonly key: {
+        readonly spaceId: 1;
+        readonly userId: 1;
+        readonly 'views.viewId': 1;
+        readonly pinned: -1;
+        readonly sortAt: -1;
+        readonly id: -1;
+    };
+}, {
+    readonly name: 'ix_inbox_view_priority';
+    readonly key: {
+        readonly spaceId: 1;
+        readonly userId: 1;
+        readonly 'views.viewId': 1;
+        readonly pinned: -1;
+        readonly priorityScore: -1;
+        readonly sortAt: -1;
+        readonly id: -1;
+    };
+}, {
+    readonly name: 'ix_inbox_view_status_activity';
+    readonly key: {
+        readonly spaceId: 1;
+        readonly userId: 1;
+        readonly 'views.viewId': 1;
+        readonly 'snapshot.status': 1;
+        readonly sortAt: -1;
+        readonly id: -1;
+    };
+}, {
+    readonly name: 'ix_inbox_view_queue_activity';
+    readonly key: {
+        readonly spaceId: 1;
+        readonly userId: 1;
+        readonly 'views.viewId': 1;
+        readonly 'snapshot.queueId': 1;
+        readonly sortAt: -1;
+        readonly id: -1;
+    };
+}];
+/**
+ * MongoDB indexes for user_inbox_counters.
+ *
+ * The unique index also serves reads for all views of a user through its
+ * spaceId + userId prefix.
+ */
+export declare const USER_INBOX_COUNTER_INDEXES: readonly [{
+    readonly name: 'uq_inbox_counter_user_view';
+    readonly key: {
+        readonly spaceId: 1;
+        readonly userId: 1;
+        readonly viewId: 1;
+    };
+    readonly unique: true;
+}];
+/**
+ * MongoDB indexes for durable processor idempotency receipts.
+ */
+export declare const INBOX_PROCESSOR_RECEIPT_INDEXES: readonly [{
+    readonly name: 'uq_inbox_processor_source_scope';
+    readonly key: {
+        readonly processor: 1;
+        readonly sourceEventId: 1;
+        readonly scopeKey: 1;
+    };
+    readonly unique: true;
+}];
+export type InboxPaginationSort = 'activity' | 'priority';
+/**
+ * Seek-pagination cursor matching ix_inbox_view_activity.
+ */
+export interface InboxActivityCursor {
+    sort: 'activity';
+    pinned: boolean;
+    sortAt: Date;
+    id: ID;
+}
+/**
+ * Seek-pagination cursor matching ix_inbox_view_priority.
+ */
+export interface InboxPriorityCursor {
+    sort: 'priority';
+    pinned: boolean;
+    priorityScore: number;
+    sortAt: Date;
+    id: ID;
+}
+export type InboxPaginationCursor = InboxActivityCursor | InboxPriorityCursor;
+/**
+ * Query contract for one logical inbox view.
+ *
+ * Implementations must use seek pagination with cursor; skip pagination is not
+ * compatible with frequently changing sortAt values.
+ */
+interface InboxPageQueryBase {
+    spaceId: ID;
+    userId: ID;
+    viewId: InboxViewId;
+    limit: number;
+}
+export type InboxPageQuery = (InboxPageQueryBase & {
+    sort: 'activity';
+    cursor?: InboxActivityCursor;
+}) | (InboxPageQueryBase & {
+    sort: 'priority';
+    cursor?: InboxPriorityCursor;
+});
+export {};

package/dist/src/Conversations/InboxMongo.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INBOX_PROCESSOR_RECEIPT_INDEXES = exports.USER_INBOX_COUNTER_INDEXES = exports.USER_INBOX_ITEM_INDEXES = exports.CONVERSATION_SUBSCRIPTION_INDEXES = exports.INBOX_PROCESSOR_RECEIPTS_COLLECTION = exports.USER_INBOX_COUNTERS_COLLECTION = exports.USER_INBOX_ITEMS_COLLECTION = exports.CONVERSATION_SUBSCRIPTIONS_COLLECTION = void 0;
+exports.CONVERSATION_SUBSCRIPTIONS_COLLECTION = 'conversation_subscriptions';
+exports.USER_INBOX_ITEMS_COLLECTION = 'user_inbox_items';
+exports.USER_INBOX_COUNTERS_COLLECTION = 'user_inbox_counters';
+exports.INBOX_PROCESSOR_RECEIPTS_COLLECTION = 'inbox_processor_receipts';
+/**
+ * MongoDB indexes for conversation_subscriptions.
+ *
+ * The unique index enforces one current subscription state per
+ * user/conversation. The follower index resolves the active followers that
+ * InboxAudienceResolver receives as input.
+ */
+exports.CONVERSATION_SUBSCRIPTION_INDEXES = [
+    {
+        name: 'uq_subscription_user_conversation',
+        key: {
+            spaceId: 1,
+            userId: 1,
+            conversationId: 1,
+        },
+        unique: true,
+    },
+    {
+        name: 'ix_subscription_conversation_followers',
+        key: {
+            spaceId: 1,
+            conversationId: 1,
+            status: 1,
+            userId: 1,
+        },
+    },
+];
+/**
+ * MongoDB indexes for user_inbox_items.
+ *
+ * views.viewId is the only array field in each compound index. Do not add
+ * views.visibilityReasons to these indexes: MongoDB compound multikey indexes
+ * must not combine multiple array paths.
+ */
+exports.USER_INBOX_ITEM_INDEXES = [
+    {
+        name: 'uq_inbox_item_user_conversation',
+        key: {
+            spaceId: 1,
+            userId: 1,
+            conversationId: 1,
+        },
+        unique: true,
+    },
+    {
+        name: 'ix_inbox_view_activity',
+        key: {
+            spaceId: 1,
+            userId: 1,
+            'views.viewId': 1,
+            pinned: -1,
+            sortAt: -1,
+            id: -1,
+        },
+    },
+    {
+        name: 'ix_inbox_view_priority',
+        key: {
+            spaceId: 1,
+            userId: 1,
+            'views.viewId': 1,
+            pinned: -1,
+            priorityScore: -1,
+            sortAt: -1,
+            id: -1,
+        },
+    },
+    {
+        name: 'ix_inbox_view_status_activity',
+        key: {
+            spaceId: 1,
+            userId: 1,
+            'views.viewId': 1,
+            'snapshot.status': 1,
+            sortAt: -1,
+            id: -1,
+        },
+    },
+    {
+        name: 'ix_inbox_view_queue_activity',
+        key: {
+            spaceId: 1,
+            userId: 1,
+            'views.viewId': 1,
+            'snapshot.queueId': 1,
+            sortAt: -1,
+            id: -1,
+        },
+    },
+];
+/**
+ * MongoDB indexes for user_inbox_counters.
+ *
+ * The unique index also serves reads for all views of a user through its
+ * spaceId + userId prefix.
+ */
+exports.USER_INBOX_COUNTER_INDEXES = [
+    {
+        name: 'uq_inbox_counter_user_view',
+        key: {
+            spaceId: 1,
+            userId: 1,
+            viewId: 1,
+        },
+        unique: true,
+    },
+];
+/**
+ * MongoDB indexes for durable processor idempotency receipts.
+ */
+exports.INBOX_PROCESSOR_RECEIPT_INDEXES = [
+    {
+        name: 'uq_inbox_processor_source_scope',
+        key: {
+            processor: 1,
+            sourceEventId: 1,
+            scopeKey: 1,
+        },
+        unique: true,
+    },
+];

package/dist/src/Conversations/InboxProjection.d.ts

@@ -0,0 +1,162 @@
+import { ConversationInboxSnapshot, ID, InboxViewId, UserInboxItemView } from './Conversation';
+import { ConversationQueue } from './Queue';
+import { ConversationAssignmentChanged } from './Transfer';
+export type InboxProcessorName = 'inbox-audience-resolver' | 'inbox-item-projector' | 'inbox-counter-projector';
+/**
+ * Queue membership snapshot used while resolving an assignment change.
+ *
+ * Produced by: assignment-change consumer.
+ * Consumed by: InboxAudienceResolver.
+ * Used when: previous/current queue audiences must be expanded from groups
+ * into concrete users without embedding membership in the integration event.
+ */
+export interface QueueAudienceResolutionContext {
+    queue: ConversationQueue;
+    memberUserIds: ID[];
+    activeMemberUserIds: ID[];
+    supervisorUserIds: ID[];
+}
+/**
+ * Complete input for calculating desired inbox visibility.
+ *
+ * Produced by: ConversationAssignmentChanged consumer.
+ * Consumed by: InboxAudienceResolver.
+ * Used when: an assignment/transfer changes queue, owner or status and the
+ * desired per-user inbox audience must be recalculated.
+ */
+export interface InboxAudienceResolverInput {
+    sourceEvent: ConversationAssignmentChanged;
+    snapshot: ConversationInboxSnapshot;
+    previousQueue?: QueueAudienceResolutionContext;
+    currentQueue?: QueueAudienceResolutionContext;
+    participantUserIds: ID[];
+    followerUserIds: ID[];
+}
+/**
+ * Visibility of one conversation inside one logical inbox view.
+ *
+ * Produced by: InboxAudienceResolver.
+ * Consumed by: inbox item projection planner/projector.
+ * Used when: multiple independent reasons can preserve the same view without
+ * generating duplicate inbox items or duplicate counter increments.
+ */
+export type ResolvedInboxView = UserInboxItemView;
+/**
+ * Desired inbox visibility for a single user after applying the source event.
+ *
+ * Produced by: InboxAudienceResolver.
+ * Consumed by: inbox item projection planner/projector.
+ * Used when: the projector compares desired visibility with the materialized
+ * user_inbox_items state.
+ */
+export interface ResolvedInboxUserVisibility {
+    userId: ID;
+    views: ResolvedInboxView[];
+}
+/**
+ * Full audience resolution result for one conversation version.
+ *
+ * Produced by: InboxAudienceResolver.
+ * Consumed by: inbox item projection planner/projector.
+ * Used when: all affected users must be diffed against their existing
+ * user_inbox_items documents.
+ */
+export interface ResolvedInboxAudience {
+    sourceEventId: ID;
+    spaceId: ID;
+    conversationId: ID;
+    conversationVersion: number;
+    snapshot: ConversationInboxSnapshot;
+    users: ResolvedInboxUserVisibility[];
+    resolvedAt: Date;
+}
+/**
+ * Processor boundary for pure audience calculation.
+ *
+ * Called by: ConversationAssignmentChanged consumer.
+ * Returns to: inbox item projection planner/projector.
+ */
+export interface InboxAudienceResolver {
+    resolve(input: InboxAudienceResolverInput): Promise<ResolvedInboxAudience>;
+}
+export type InboxProjectionOperation = 'insert' | 'update' | 'delete';
+/**
+ * Idempotent mutation plan for one user's materialized conversation item.
+ *
+ * Produced by: inbox item projection planner.
+ * Consumed by: inbox item projector; after persistence it is also the input
+ * used to derive InboxCounterDelta messages.
+ * Used when: desired audience is compared with the existing projection.
+ *
+ * id must be deterministic from:
+ * sourceEventId + userId + conversationId.
+ */
+export interface InboxProjectionDelta {
+    id: ID;
+    sourceEventId: ID;
+    spaceId: ID;
+    userId: ID;
+    conversationId: ID;
+    conversationVersion: number;
+    operation: InboxProjectionOperation;
+    previous?: ResolvedInboxUserVisibility;
+    current?: ResolvedInboxUserVisibility;
+    snapshot?: ConversationInboxSnapshot;
+    createdAt: Date;
+}
+/**
+ * Atomic counter change for one user/view caused by one projection delta.
+ *
+ * Produced by: inbox item projector after determining the actual persisted
+ * before/after state.
+ * Consumed by: InboxCounterProjector.
+ * Used when: view membership, requiresAction or unread state changes.
+ *
+ * id must be deterministic from:
+ * sourceEventId + userId + conversationId + viewId.
+ */
+export interface InboxCounterDelta {
+    id: ID;
+    sourceEventId: ID;
+    spaceId: ID;
+    userId: ID;
+    conversationId: ID;
+    viewId: InboxViewId;
+    conversationVersion: number;
+    totalDelta: -1 | 0 | 1;
+    requiresActionDelta: -1 | 0 | 1;
+    unreadDelta: -1 | 0 | 1;
+    createdAt: Date;
+}
+/**
+ * Durable idempotency receipt for a processor side effect.
+ *
+ * Produced and consumed by: inbox item projector or InboxCounterProjector.
+ * Used when: the same outbox event/delta is delivered more than once.
+ *
+ * Unique key:
+ * processor + sourceEventId + scopeKey.
+ *
+ * scopeKey examples:
+ * - item projector: userId + conversationId
+ * - counter projector: userId + conversationId + viewId
+ */
+export interface InboxProcessorReceipt {
+    id: ID;
+    processor: InboxProcessorName;
+    sourceEventId: ID;
+    scopeKey: string;
+    spaceId: ID;
+    conversationId: ID;
+    conversationVersion: number;
+    processedAt: Date;
+}
+/**
+ * Processor boundary for applying counter deltas idempotently.
+ *
+ * Called by: inbox item projector.
+ * Mutates: user_inbox_counters and InboxProcessorReceipt in one transaction.
+ */
+export interface InboxCounterProjector {
+    apply(delta: InboxCounterDelta): Promise<void>;
+}

package/dist/src/Conversations/InboxProjection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/Conversations/Label.d.ts

@@ -1,6 +1,6 @@
 interface ILabel {
     id?: string | null;
-    tenantId?: string | null;
+    spaceId?: string | null;
     name?: string | null;
     color?: string | null;
     createdAt?: string | null;

package/dist/src/Conversations/Outbox.d.ts

@@ -0,0 +1,24 @@
+export declare const OUTBOX_EVENTS_COLLECTION = "outbox_events";
+export type OutboxEventStatus = 'pending' | 'publishing' | 'published' | 'failed';
+/**
+ * Transactional outbox record persisted with the aggregate mutation.
+ */
+export interface OutboxEvent<TPayload> {
+    id: string;
+    spaceId: string;
+    aggregateType: string;
+    aggregateId: string;
+    eventType: string;
+    schemaVersion: number;
+    payload: TPayload;
+    status: OutboxEventStatus;
+    attempts: number;
+    availableAt: Date;
+    lockedAt?: Date;
+    lockedUntil?: Date;
+    lockedBy?: string;
+    createdAt: Date;
+    lastAttemptAt?: Date;
+    publishedAt?: Date;
+    lastError?: string;
+}

package/dist/src/Conversations/Outbox.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTBOX_EVENTS_COLLECTION = void 0;
+exports.OUTBOX_EVENTS_COLLECTION = 'outbox_events';

package/dist/src/Conversations/Queue.d.ts

@@ -0,0 +1,107 @@
+import { ID } from './Conversation';
+import { QueueRoutingPolicy } from './Routing';
+export declare const CONVERSATION_QUEUES_COLLECTION = "conversation_queues";
+export type QueueSlaTransferBehavior = 'preserve' | 'restart' | 'recalculate';
+export type ConversationQueueSlaConfig = {
+    enabled: false;
+    policyId?: never;
+    policyVersion?: never;
+    onTransferIn?: never;
+} | {
+    enabled: true;
+    policyId: ID;
+    policyVersion: number;
+    onTransferIn: QueueSlaTransferBehavior;
+};
+/**
+ * distribution:
+ *   visibility follows shared, manual_pull or exclusive routing semantics.
+ * all_current:
+ *   all authorized queue members can see current queue conversations.
+ */
+export type QueueMemberAudienceMode = 'distribution' | 'all_current' | 'none';
+export type QueueSupervisorAudienceMode = 'all_current' | 'sla_only' | 'escalations_only' | 'none';
+export interface ConversationQueueAudienceConfig {
+    members: {
+        mode: QueueMemberAudienceMode;
+        requireActiveParticipation: boolean;
+        includeResolved: boolean;
+    };
+    supervisors: {
+        mode: QueueSupervisorAudienceMode;
+        includeResolved: boolean;
+    };
+}
+export interface ConversationQueueInfo {
+    id: ID;
+    name: string;
+    color?: string;
+    enabled: boolean;
+}
+/**
+ * Conversation routing, supervision and reporting boundary.
+ * Groups only provide user membership; they never own conversations.
+ */
+export interface ConversationQueue {
+    id: ID;
+    spaceId: ID;
+    name: string;
+    description?: string;
+    color?: string;
+    enabled: boolean;
+    /**
+     * Higher values are evaluated first when multiple queues match.
+     */
+    priority: number;
+    memberGroupIds: ID[];
+    supervisorGroupIds: ID[];
+    routing: QueueRoutingPolicy;
+    sla: ConversationQueueSlaConfig;
+    audience: ConversationQueueAudienceConfig;
+    version: number;
+    createdAt: Date;
+    createdByUserId?: ID;
+    updatedAt: Date;
+    updatedByUserId?: ID;
+}
+/**
+ * Editable Queue definition sent by clients.
+ *
+ * It excludes id, version and audit fields controlled by the backend. Nested
+ * routing, SLA and audience objects use full-replacement semantics.
+ */
+export interface ConversationQueueDefinitionInput {
+    name: string;
+    description?: string;
+    color?: string;
+    enabled: boolean;
+    priority: number;
+    memberGroupIds: ID[];
+    supervisorGroupIds: ID[];
+    routing: QueueRoutingPolicy;
+    sla: ConversationQueueSlaConfig;
+    audience: ConversationQueueAudienceConfig;
+}
+/**
+ * Creates a Queue. commandId makes retries idempotent. The backend assigns
+ * queue id, version and audit fields.
+ */
+export interface CreateConversationQueueRequest {
+    commandId: ID;
+    spaceId: ID;
+    definition: ConversationQueueDefinitionInput;
+}
+/**
+ * Replaces the editable definition of an existing Queue.
+ *
+ * expectedVersion is the version loaded by the client; it is not incremented
+ * by the client. The backend rejects stale writes and returns the updated
+ * ConversationQueue with its new version and audit fields.
+ */
+export interface UpdateConversationQueueRequest {
+    commandId: ID;
+    spaceId: ID;
+    queueId: ID;
+    expectedVersion: number;
+    definition: ConversationQueueDefinitionInput;
+}

package/dist/src/Conversations/Queue.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONVERSATION_QUEUES_COLLECTION = void 0;
+exports.CONVERSATION_QUEUES_COLLECTION = 'conversation_queues';