@remit/data-ports 0.0.85 → 0.0.87

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { deriveFilterTtl } from "./filter-ttl.js";
 export type { IAccountRepository } from "./interfaces/account.js";
 export type { IAccountConfigRepository } from "./interfaces/account-config.js";
 export type { IAccountExportRequestRepository } from "./interfaces/account-export-request.js";
+export type { AccountDataPurgeEvent, AccountDeleteEvent, AccountExportEvent, AccountFanoutEvent, OrganizeJobEvent, SenderCategoryBackApplyEvent, } from "./interfaces/account-fanout-events.js";
 export type { IAccountSettingRepository } from "./interfaces/account-setting.js";
 export type { IAddressRepository } from "./interfaces/address.js";
 export type { ICalendarCollectionRepository } from "./interfaces/calendar-collection.js";
@@ -28,6 +29,7 @@ export { holdsRoom } from "./interfaces/outbox-attachment.js";
 export type { IOutboxMessageRepository } from "./interfaces/outbox-message.js";
 export { APPENDED_UID_NONE, APPENDED_UID_UNREPORTED, isSentCopyFiled, } from "./interfaces/outbox-message.js";
 export type { IQuarantineRepository } from "./interfaces/quarantine.js";
+export { type FifoQueueMessage, type FifoQueueProducer, type GroupedQueueMessage, type GroupedQueueProducer, QUEUE_BATCH_LIMIT, type QueueBatchResult, type QueueKind, type QueueMessage, type QueueProducer, type QueueProducerOf, } from "./interfaces/queue.js";
 export type { ISenderSignerStandingRepository } from "./interfaces/sender-signer-standing.js";
 export type { ISyncWarningRepository, SurfacedSyncWarnings, } from "./interfaces/sync-warning.js";
 export type { IThreadMessageRepository } from "./interfaces/thread-message.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export { deriveFilterTtl } from "./filter-ttl.js";
 export { holdsRoom } from "./interfaces/outbox-attachment.js";
 export { APPENDED_UID_NONE, APPENDED_UID_UNREPORTED, isSentCopyFiled, } from "./interfaces/outbox-message.js";
+export { QUEUE_BATCH_LIMIT, } from "./interfaces/queue.js";
 export { abandonedMutationOf, hasAbandonedDelete, hasAbandonedMove, } from "./message-settlement.js";
 export { FILTER_NO_ACTION, isSenderMuted, isSenderMuteFilter, } from "./sender-mute.js";

package/dist/interfaces/account-fanout-events.d.ts

@@ -0,0 +1,58 @@
+import type { ThreadMessageItem } from "../types.js";
+export type AccountDeleteEvent = {
+    type: "AccountDelete";
+    accountConfigId: string;
+};
+/**
+ * Per-account hard-delete. Purges ONE mail account's data (mailboxes,
+ * messages, body parts, thread messages, S3 objects) while
+ * keeping the AccountConfig/tenant and any sibling accounts intact. Emitted
+ * by the API on `deleteAccount`; consumed by the fanout worker.
+ */
+export type AccountDataPurgeEvent = {
+    type: "AccountDataPurge";
+    accountId: string;
+    accountConfigId: string;
+};
+export type AccountExportEvent = {
+    type: "AccountExport";
+    accountConfigId: string;
+    accountExportRequestId: string;
+};
+/**
+ * A "all like these" back-apply job (RFC 034, #1278). Rides the same
+ * account-fanout queue as export: the API writes a Pending OrganizeJobRequest
+ * row and enqueues this; the fanout worker matches the corpus and applies the
+ * action, driving the row to Complete/Failed. Never creates a Filter row.
+ */
+export type OrganizeJobEvent = {
+    type: "OrganizeJob";
+    accountConfigId: string;
+    organizeJobId: string;
+};
+/**
+ * Retroactive half of a sender-category override (#415, RFC 039 Decision 3).
+ * Rides the same account-fanout queue as the organize back-apply: the API
+ * enqueues one when `Address.flags.category` is SET, and the fanout worker
+ * re-labels a bounded recent batch of that sender's already-classified mail.
+ * A CLEAR never enqueues one: reverting to auto-classification says nothing
+ * about what the classifier would have answered, and re-deriving it would need
+ * every message's body back.
+ *
+ * `category` and `categorySetAt` together name WHICH set this job was fired
+ * for, and the worker refuses a job whose set no longer stands on the Address.
+ * That check is what the standard queue's semantics make necessary rather than
+ * merely tidy: delivery is at-least-once and unordered, so without it a job
+ * that fails and redelivers after the user has corrected the category re-labels
+ * those 500 messages back to the superseded one, leaving the flag and the mail
+ * permanently disagreeing with nothing to reconcile them.
+ */
+export type SenderCategoryBackApplyEvent = {
+    type: "SenderCategoryBackApply";
+    accountConfigId: string;
+    addressId: string;
+    normalizedEmail: string;
+    category: ThreadMessageItem["category"];
+    categorySetAt: number;
+};
+export type AccountFanoutEvent = AccountDeleteEvent | AccountDataPurgeEvent | AccountExportEvent | OrganizeJobEvent | SenderCategoryBackApplyEvent;

package/dist/interfaces/account-fanout-events.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/message.d.ts

@@ -11,6 +11,13 @@ export interface IMessageRepository {
     update(messageId: string, input: UpdateMessageInput): Promise<MessageItem>;
     clearBodyStorageKey(messageId: string): Promise<MessageItem>;
     clearSpamReport(messageId: string): Promise<MessageItem>;
+    setSearchText(messageId: string, text: string): Promise<void>;
+    copySearchText(sourceMessageId: string, targetMessageId: string): Promise<void>;
+    syncSearch(messageIds: string[]): Promise<void>;
+    listMissingSearchText(after: string, limit: number): Promise<Array<{
+        messageId: string;
+        bodyStorageKey: string;
+    }>>;
     delete(messageId: string): Promise<void>;
     deleteMany(messageIds: string[]): Promise<void>;
     /**

package/dist/interfaces/queue.d.ts

@@ -0,0 +1,22 @@
+export interface QueueMessage<T> {
+    readonly body: T;
+}
+export interface GroupedQueueMessage<T> extends QueueMessage<T> {
+    readonly groupId: string;
+}
+export interface FifoQueueMessage<T> extends GroupedQueueMessage<T> {
+    readonly deduplicationId: string;
+}
+export interface QueueBatchResult {
+    readonly refused: ReadonlySet<number>;
+}
+export declare const QUEUE_BATCH_LIMIT = 10;
+export type QueueKind = "Standard" | "Grouped" | "Fifo";
+export interface QueueProducerOf<K extends QueueKind, M> {
+    readonly kind: K;
+    readonly send: (message: M) => Promise<void>;
+    readonly sendBatch: (messages: readonly M[]) => Promise<QueueBatchResult>;
+}
+export type QueueProducer<T> = QueueProducerOf<"Standard", QueueMessage<T>>;
+export type GroupedQueueProducer<T> = QueueProducerOf<"Grouped", GroupedQueueMessage<T>>;
+export type FifoQueueProducer<T> = QueueProducerOf<"Fifo", FifoQueueMessage<T>>;

package/dist/interfaces/queue.js

@@ -0,0 +1,2 @@
+// The smallest batch every queue backend accepts (SQS caps a batch at ten).
+export const QUEUE_BATCH_LIMIT = 10;

package/dist/recording-queue.d.ts

@@ -0,0 +1,15 @@
+import type { FifoQueueProducer, GroupedQueueProducer, QueueProducer } from "./interfaces/queue.js";
+export interface RecordedMessage {
+    body: Record<string, unknown>;
+    groupId: string | undefined;
+    deduplicationId: string | undefined;
+}
+export interface RecordingQueue extends QueueProducer<unknown> {
+    readonly fifo: FifoQueueProducer<unknown>;
+    readonly grouped: GroupedQueueProducer<unknown>;
+    readonly sent: RecordedMessage[];
+    readonly answer: (next: () => Promise<unknown>) => void;
+    readonly refuse: (positions: readonly number[]) => void;
+}
+export declare const recordingQueue: () => RecordingQueue;
+export declare const failingQueue: (error: unknown) => RecordingQueue;

package/dist/recording-queue.js

@@ -0,0 +1,50 @@
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stringField = (message, field) => {
+    const value = Reflect.get(message, field);
+    return typeof value === "string" ? value : undefined;
+};
+const recorded = (message) => {
+    const body = JSON.parse(JSON.stringify(message.body));
+    if (!isRecord(body))
+        throw new Error("A queued body must be an object");
+    return {
+        body,
+        groupId: stringField(message, "groupId"),
+        deduplicationId: stringField(message, "deduplicationId"),
+    };
+};
+export const recordingQueue = () => {
+    const sent = [];
+    let answer = async () => ({});
+    let refused = new Set();
+    const send = async (message) => {
+        sent.push(recorded(message));
+        await answer();
+    };
+    const sendBatch = async (messages) => {
+        sent.push(...messages.map(recorded));
+        await answer();
+        return { refused };
+    };
+    return {
+        kind: "Standard",
+        fifo: { kind: "Fifo", send, sendBatch },
+        grouped: { kind: "Grouped", send, sendBatch },
+        sent,
+        answer: (next) => {
+            answer = next;
+        },
+        refuse: (positions) => {
+            refused = new Set(positions);
+        },
+        send,
+        sendBatch,
+    };
+};
+export const failingQueue = (error) => {
+    const queue = recordingQueue();
+    queue.answer(async () => {
+        throw error;
+    });
+    return queue;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/data-ports",
-	"version": "0.0.85",
+	"version": "0.0.87",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -26,11 +26,13 @@
 	},
 	"dependencies": {
 		"@remit/domain-enums": "*",
-		"short-uuid": "*",
-		"uuid": "*",
-		"zod": "^3.25.0",
+		"short-uuid": "^6.0.3",
+		"uuid": "^13.0.2",
 		"@remit/api-zod-schemas": "*"
 	},
+	"peerDependencies": {
+		"zod": "^3.25.0"
+	},
 	"license": "MIT",
 	"publishConfig": {
 		"access": "public"