@serve.zone/coremail 1.0.0

package/dist_ts/classes.maintenance.d.ts

@@ -0,0 +1,16 @@
+import type { ICoreMailModels } from './classes.models.js';
+import type { CoreMailStorage } from './classes.storage.js';
+export declare class CoreMailMaintenanceService {
+    private readonly models;
+    private readonly storage;
+    private readonly now;
+    private sweepTimer;
+    private sweepTask;
+    private sweepController;
+    constructor(models: ICoreMailModels, storage: CoreMailStorage, now?: () => number);
+    start(): void;
+    stop(): Promise<void>;
+    sweep(signalArg?: AbortSignal): Promise<void>;
+    private purgeSubmission;
+    private runSweep;
+}

package/dist_ts/classes.maintenance.js

@@ -0,0 +1,339 @@
+import * as plugins from './plugins.js';
+import { logCoreMailFailure } from './coremail.log.js';
+const sweepIntervalMs = 60_000;
+const batchSize = 100;
+const transferRetirementGraceMs = plugins.serveZoneInterfaces.data.coreMailLimits.transferGrantTtlMs
+    + plugins.serveZoneInterfaces.data.coreMailLimits.transferOverallTimeoutMs
+    + 2 * 60_000;
+export class CoreMailMaintenanceService {
+    models;
+    storage;
+    now;
+    sweepTimer = null;
+    sweepTask = null;
+    sweepController = null;
+    constructor(models, storage, now = Date.now) {
+        this.models = models;
+        this.storage = storage;
+        this.now = now;
+    }
+    start() {
+        if (this.sweepTimer)
+            return;
+        this.sweepTimer = setInterval(() => {
+            void this.runSweep();
+        }, sweepIntervalMs);
+        this.sweepTimer.unref?.();
+    }
+    async stop() {
+        if (this.sweepTimer) {
+            clearInterval(this.sweepTimer);
+            this.sweepTimer = null;
+        }
+        this.sweepController?.abort();
+        await this.sweepTask?.catch(() => undefined);
+    }
+    async sweep(signalArg) {
+        const now = this.now();
+        const terminalOutboundCutoff = now
+            - plugins.serveZoneInterfaces.data.coreMailRetentionPolicy.terminalOutboundMs;
+        const acknowledgedInboundCutoff = now
+            - plugins.serveZoneInterfaces.data.coreMailRetentionPolicy.acknowledgedInboundMs;
+        const idempotencyReceiptCutoff = now
+            - plugins.serveZoneInterfaces.data.coreMailRetentionPolicy.idempotencyReceiptMs;
+        const expiredCapabilityCutoff = now
+            - plugins.serveZoneInterfaces.data.coreMailRetentionPolicy.expiredCapabilityMs;
+        const transferRetirementCutoff = now - transferRetirementGraceMs;
+        while (!signalArg?.aborted) {
+            const terminalSubmissions = await this.models.Submission.exact.findStored({
+                filter: {
+                    state: { $in: ['delivered', 'failed', 'deadLettered'] },
+                    terminalAt: { $lte: terminalOutboundCutoff },
+                    $or: [
+                        { retiringAt: { $exists: false } },
+                        { retiringAt: { $lte: transferRetirementCutoff } },
+                    ],
+                },
+                sort: { terminalAt: 1, submissionId: 1 },
+                limit: batchSize,
+            });
+            for (const submission of terminalSubmissions) {
+                signalArg?.throwIfAborted();
+                await this.purgeSubmission(submission, signalArg);
+            }
+            if (terminalSubmissions.length < batchSize)
+                break;
+        }
+        while (!signalArg?.aborted) {
+            const abandonedSubmissions = await this.models.Submission.exact.findStored({
+                filter: {
+                    state: { $in: ['preparing', 'uploading', 'ready'] },
+                    updatedAt: { $lte: idempotencyReceiptCutoff },
+                    $or: [
+                        { leaseExpiresAt: { $exists: false } },
+                        { leaseExpiresAt: { $lte: now } },
+                    ],
+                },
+                sort: { createdAt: 1, submissionId: 1 },
+                limit: batchSize,
+            });
+            for (const submission of abandonedSubmissions) {
+                signalArg?.throwIfAborted();
+                const retirement = await this.models.Submission.exact.transition({
+                    current: submission,
+                    change: (modelArg) => {
+                        modelArg.state = 'failed';
+                        modelArg.error = { code: 'STATE_CONFLICT', retryable: false };
+                        modelArg.terminalAt = submission.updatedAt;
+                        modelArg.retiringAt = now;
+                        modelArg.updatedAt = now;
+                        modelArg.revision += 1;
+                        delete modelArg.nextAttemptAt;
+                        delete modelArg.workerRetryAt;
+                        delete modelArg.deliveredAt;
+                        delete modelArg.leaseOwnerTaskId;
+                        delete modelArg.leaseToken;
+                        delete modelArg.leaseExpiresAt;
+                    },
+                });
+                if (retirement.status !== 'transitioned')
+                    continue;
+            }
+            if (abandonedSubmissions.length < batchSize)
+                break;
+        }
+        while (!signalArg?.aborted) {
+            const deliveries = await this.models.InboundDelivery.exact.findStored({
+                filter: {
+                    state: 'acknowledged',
+                    updatedAt: { $lte: acknowledgedInboundCutoff },
+                },
+                sort: { updatedAt: 1, deliveryId: 1 },
+                limit: batchSize,
+            });
+            for (const delivery of deliveries) {
+                signalArg?.throwIfAborted();
+                const retainedReferences = await this.models.InboundDelivery.exact.count({
+                    rawMimeObjectKey: delivery.rawMimeObjectKey,
+                    deliveryId: { $ne: delivery.deliveryId },
+                    $or: [
+                        { state: { $ne: 'acknowledged' } },
+                        { updatedAt: { $gt: acknowledgedInboundCutoff } },
+                    ],
+                });
+                if (retainedReferences === 0) {
+                    await this.storage.purgeExact(delivery.rawMimeObjectKey, signalArg);
+                }
+                await this.models.InboundDelivery.exact.delete({ current: delivery });
+            }
+            if (deliveries.length < batchSize)
+                break;
+        }
+        let handoffCursor;
+        while (!signalArg?.aborted) {
+            const incompleteHandoffs = await this.models.InboundHandoff.exact.findStored({
+                filter: {
+                    $and: [
+                        {
+                            $or: [
+                                {
+                                    state: { $in: ['prepared', 'uploaded', 'failed'] },
+                                    updatedAt: { $lte: idempotencyReceiptCutoff },
+                                },
+                                {
+                                    state: 'retiring',
+                                    retiringAt: { $lte: transferRetirementCutoff },
+                                },
+                            ],
+                        },
+                        ...(handoffCursor
+                            ? [{
+                                    $or: [
+                                        { createdAt: { $gt: handoffCursor.createdAt } },
+                                        {
+                                            createdAt: handoffCursor.createdAt,
+                                            handoffId: { $gt: handoffCursor.handoffId },
+                                        },
+                                    ],
+                                }]
+                            : []),
+                    ],
+                },
+                sort: { createdAt: 1, handoffId: 1 },
+                limit: batchSize,
+            });
+            for (const handoff of incompleteHandoffs) {
+                signalArg?.throwIfAborted();
+                let retiringHandoff = handoff;
+                if (handoff.state !== 'retiring') {
+                    const retirement = await this.models.InboundHandoff.exact.transition({
+                        current: handoff,
+                        change: (modelArg) => {
+                            modelArg.state = 'retiring';
+                            modelArg.retiringAt = now;
+                            modelArg.updatedAt = now;
+                            modelArg.revision += 1;
+                        },
+                    });
+                    if (retirement.status !== 'transitioned')
+                        continue;
+                    continue;
+                }
+                const deliveryReferences = await this.models.InboundDelivery.exact.count({
+                    rawMimeObjectKey: retiringHandoff.objectKey,
+                });
+                if (deliveryReferences === 0) {
+                    await this.storage.purgeExact(retiringHandoff.objectKey, signalArg);
+                    await this.models.InboundHandoff.exact.delete({ current: retiringHandoff });
+                }
+            }
+            const lastHandoff = incompleteHandoffs.at(-1);
+            if (!lastHandoff || incompleteHandoffs.length < batchSize)
+                break;
+            handoffCursor = {
+                createdAt: lastHandoff.createdAt,
+                handoffId: lastHandoff.handoffId,
+            };
+        }
+        while (!signalArg?.aborted) {
+            const completedHandoffs = await this.models.InboundHandoff.exact.findStored({
+                filter: {
+                    state: 'completed',
+                    completedAt: { $lte: idempotencyReceiptCutoff },
+                },
+                sort: { completedAt: 1, handoffId: 1 },
+                limit: batchSize,
+            });
+            for (const handoff of completedHandoffs) {
+                signalArg?.throwIfAborted();
+                await this.models.InboundHandoff.exact.delete({ current: handoff });
+            }
+            if (completedHandoffs.length < batchSize)
+                break;
+        }
+        while (!signalArg?.aborted) {
+            const activeState = await this.models.State.exact.findStoredOne({
+                stateId: 'active',
+            });
+            const snapshots = await this.models.DesiredSnapshot.exact.findStored({
+                filter: {
+                    $or: [
+                        {
+                            state: { $in: ['staged', 'superseded', 'failed'] },
+                            updatedAt: { $lte: idempotencyReceiptCutoff },
+                        },
+                        {
+                            state: 'retiring',
+                            retiringAt: { $lte: transferRetirementCutoff },
+                        },
+                    ],
+                    ...(activeState ? { snapshotId: { $ne: activeState.snapshotId } } : {}),
+                },
+                sort: { createdAt: 1, snapshotId: 1 },
+                limit: batchSize,
+            });
+            for (const snapshot of snapshots) {
+                signalArg?.throwIfAborted();
+                let retiringSnapshot = snapshot;
+                if (snapshot.state !== 'retiring') {
+                    const retirement = await this.models.DesiredSnapshot.exact.transition({
+                        current: snapshot,
+                        change: (modelArg) => {
+                            modelArg.state = 'retiring';
+                            modelArg.retiringAt = now;
+                            modelArg.updatedAt = now;
+                        },
+                    });
+                    if (retirement.status !== 'transitioned')
+                        continue;
+                    continue;
+                }
+                await this.storage.purgeExact(retiringSnapshot.objectKey, signalArg);
+                await this.models.DesiredSnapshot.exact.delete({ current: retiringSnapshot });
+            }
+            if (snapshots.length < batchSize)
+                break;
+        }
+        while (!signalArg?.aborted) {
+            const grants = await this.models.TransferGrant.exact.findStored({
+                filter: { expiresAt: { $lte: expiredCapabilityCutoff } },
+                sort: { expiresAt: 1, grantId: 1 },
+                limit: batchSize,
+            });
+            for (const grant of grants) {
+                signalArg?.throwIfAborted();
+                await this.models.TransferGrant.exact.delete({ current: grant });
+            }
+            if (grants.length < batchSize)
+                break;
+        }
+        while (!signalArg?.aborted) {
+            const handles = await this.models.RecipientHandle.exact.findStored({
+                filter: { expiresAt: { $lte: expiredCapabilityCutoff } },
+                sort: { expiresAt: 1, routingHandle: 1 },
+                limit: batchSize,
+            });
+            for (const handle of handles) {
+                signalArg?.throwIfAborted();
+                await this.models.RecipientHandle.exact.delete({ current: handle });
+            }
+            if (handles.length < batchSize)
+                break;
+        }
+        while (!signalArg?.aborted) {
+            const counters = await this.models.QuotaCounter.exact.findStored({
+                filter: {
+                    updatedAt: { $lte: idempotencyReceiptCutoff },
+                    $or: [{
+                            kind: { $in: ['outbound-minute', 'outbound-day'] },
+                        }, {
+                            kind: 'pending-inbound',
+                            count: 0,
+                        }],
+                },
+                sort: { updatedAt: 1, counterId: 1 },
+                limit: batchSize,
+            });
+            for (const counter of counters) {
+                signalArg?.throwIfAborted();
+                await this.models.QuotaCounter.exact.delete({ current: counter });
+            }
+            if (counters.length < batchSize)
+                break;
+        }
+    }
+    async purgeSubmission(submissionArg, signalArg) {
+        const objectKeys = new Set(submissionArg.parts.map((partArg) => partArg.objectKey));
+        if (submissionArg.mimeObjectKey)
+            objectKeys.add(submissionArg.mimeObjectKey);
+        for (const objectKey of objectKeys) {
+            signalArg?.throwIfAborted();
+            await this.storage.purgeExact(objectKey, signalArg);
+        }
+        await this.models.Submission.exact.delete({ current: submissionArg });
+    }
+    async runSweep() {
+        if (this.sweepTask)
+            return await this.sweepTask;
+        const controller = new AbortController();
+        this.sweepController = controller;
+        const task = this.sweep(controller.signal).catch(async () => {
+            if (!controller.signal.aborted) {
+                await logCoreMailFailure('retention', 'SWEEP_FAILED').catch(() => undefined);
+            }
+        });
+        this.sweepTask = task;
+        try {
+            await task;
+        }
+        finally {
+            if (this.sweepTask === task) {
+                this.sweepTask = null;
+            }
+            if (this.sweepController === controller) {
+                this.sweepController = null;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.maintenance.js","sourceRoot":"","sources":["../ts/classes.maintenance.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.models.d.ts

@@ -0,0 +1,161 @@
+import * as plugins from './plugins.js';
+import type { ISubmissionPartRecord, TTransferGrantPurpose } from './interfaces.js';
+import { type ICoreMailDesiredSnapshotRecord, type ICoreMailInboundDeliveryRecord, type ICoreMailInboundHandoffRecord, type ICoreMailQuotaCounterRecord, type ICoreMailRecipientHandleRecord, type ICoreMailStateRecord, type ICoreMailSubmissionRecord, type ICoreMailTransferGrantRecord } from './coremail.persistence.js';
+type TCoreMailSha256 = plugins.serveZoneInterfaces.data.TCoreMailSha256;
+export declare class CoreMailStateDoc extends plugins.smartdata.SmartDataDbDoc<CoreMailStateDoc, ICoreMailStateRecord> implements ICoreMailStateRecord {
+    static exact: plugins.smartdata.TExact<CoreMailStateDoc>;
+    stateId: string;
+    appliedConfigEpoch: number;
+    appliedDesiredStateDigest: TCoreMailSha256;
+    snapshotId: string;
+    updatedAt: number;
+}
+export declare class CoreMailDesiredSnapshotDoc extends plugins.smartdata.SmartDataDbDoc<CoreMailDesiredSnapshotDoc, ICoreMailDesiredSnapshotRecord> implements ICoreMailDesiredSnapshotRecord {
+    static exact: plugins.smartdata.TExact<CoreMailDesiredSnapshotDoc>;
+    snapshotId: string;
+    reconciliationId: string;
+    expectedAppliedConfigEpoch: number;
+    configEpoch: number;
+    desiredStateDigest: TCoreMailSha256;
+    lengthBytes: number;
+    objectKey: string;
+    state: 'staged' | 'active' | 'superseded' | 'failed' | 'retiring';
+    createdAt: number;
+    updatedAt: number;
+    activatedAt?: number;
+    retiringAt?: number;
+    errorCode?: plugins.serveZoneInterfaces.data.TCoreMailErrorCode;
+}
+export declare class CoreMailQuotaCounterDoc extends plugins.smartdata.SmartDataDbDoc<CoreMailQuotaCounterDoc, ICoreMailQuotaCounterRecord> implements ICoreMailQuotaCounterRecord {
+    static exact: plugins.smartdata.TExact<CoreMailQuotaCounterDoc>;
+    counterId: TCoreMailSha256;
+    tenantId: string;
+    serviceId: string;
+    bindingId: string;
+    bindingRevision: number;
+    kind: ICoreMailQuotaCounterRecord['kind'];
+    windowStartedAt?: number;
+    count: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare class CoreMailTransferGrantDoc extends plugins.smartdata.SmartDataDbDoc<CoreMailTransferGrantDoc, ICoreMailTransferGrantRecord> implements ICoreMailTransferGrantRecord {
+    static exact: plugins.smartdata.TExact<CoreMailTransferGrantDoc>;
+    grantId: string;
+    authorityKind: 'control' | 'gateway' | 'workload';
+    tenantId: string;
+    serviceId: string;
+    bindingId: string;
+    purpose: TTransferGrantPurpose;
+    method: 'PUT' | 'GET';
+    path: string;
+    bearerSha256: TCoreMailSha256;
+    expectedSha256: TCoreMailSha256;
+    lengthBytes: number;
+    contentType: string;
+    objectKey: string;
+    state: 'issued' | 'transferring' | 'consumed' | 'failed' | 'expired';
+    expiresAt: number;
+    createdAt: number;
+    consumedAt?: number;
+}
+export declare class CoreMailSubmissionDoc extends plugins.smartdata.SmartDataDbDoc<CoreMailSubmissionDoc, ICoreMailSubmissionRecord> implements ICoreMailSubmissionRecord {
+    static exact: plugins.smartdata.TExact<CoreMailSubmissionDoc>;
+    submissionId: string;
+    tenantId: string;
+    serviceId: string;
+    bindingId: string;
+    bindingRevision: number;
+    revision: number;
+    idempotencyKey: string;
+    submissionDigest: TCoreMailSha256;
+    state: plugins.serveZoneInterfaces.data.TCoreMailSubmissionState;
+    message: plugins.serveZoneInterfaces.data.ICoreMailOutboundMessageDescriptor;
+    parts: ISubmissionPartRecord[];
+    mimeObjectKey?: string;
+    mimeSha256?: TCoreMailSha256;
+    mimeLengthBytes?: number;
+    mimePublishedAt?: number;
+    transportMessageId?: string;
+    transportGrantId?: string;
+    gatewayStatusUpdatedAt?: number;
+    attempts: number;
+    nextAttemptAt?: number;
+    workerRetryAt?: number;
+    retiringAt?: number;
+    leaseOwnerTaskId?: string;
+    leaseToken?: string;
+    leaseExpiresAt?: number;
+    acceptedAt?: number;
+    deliveredAt?: number;
+    terminalAt?: number;
+    error?: plugins.serveZoneInterfaces.data.ICoreMailErrorData;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare class CoreMailInboundDeliveryDoc extends plugins.smartdata.SmartDataDbDoc<CoreMailInboundDeliveryDoc, ICoreMailInboundDeliveryRecord> implements ICoreMailInboundDeliveryRecord {
+    static exact: plugins.smartdata.TExact<CoreMailInboundDeliveryDoc>;
+    deliveryId: string;
+    tenantId: string;
+    serviceId: string;
+    bindingId: string;
+    bindingRevision: number;
+    revision: number;
+    transportDeliveryId: string;
+    state: plugins.serveZoneInterfaces.data.TCoreMailInboundDeliveryState;
+    envelope: plugins.serveZoneInterfaces.data.ICoreMailEnvelope;
+    rawMimeSha256: TCoreMailSha256;
+    rawMimeLengthBytes: number;
+    rawMimeObjectKey: string;
+    messageId?: string;
+    subject?: string;
+    receivedAt: number;
+    updatedAt: number;
+    fetchGrantId?: string;
+    acknowledgedOutcome?: plugins.serveZoneInterfaces.data.TCoreMailInboundAckOutcome;
+}
+export declare class CoreMailRecipientHandleDoc extends plugins.smartdata.SmartDataDbDoc<CoreMailRecipientHandleDoc, ICoreMailRecipientHandleRecord> implements ICoreMailRecipientHandleRecord {
+    static exact: plugins.smartdata.TExact<CoreMailRecipientHandleDoc>;
+    routingHandle: string;
+    tenantId: string;
+    serviceId: string;
+    bindingId: string;
+    bindingRevision: number;
+    maxPendingInbound: number;
+    recipient: string;
+    envelopeDigest: TCoreMailSha256;
+    state: 'issued' | 'consumed' | 'expired';
+    handoffId?: string;
+    expiresAt: number;
+    createdAt: number;
+}
+export declare class CoreMailInboundHandoffDoc extends plugins.smartdata.SmartDataDbDoc<CoreMailInboundHandoffDoc, ICoreMailInboundHandoffRecord> implements ICoreMailInboundHandoffRecord {
+    static exact: plugins.smartdata.TExact<CoreMailInboundHandoffDoc>;
+    handoffId: string;
+    revision: number;
+    transportDeliveryId: string;
+    routingHandles: string[];
+    message: plugins.serveZoneInterfaces.data.ICoreMailGatewayMessageDescriptor;
+    source: plugins.serveZoneInterfaces.data.IMailConnectionInfo;
+    state: 'prepared' | 'uploaded' | 'completed' | 'failed' | 'retiring';
+    objectKey: string;
+    grantId?: string;
+    deliveryIds: string[];
+    createdAt: number;
+    updatedAt: number;
+    completedAt?: number;
+    retiringAt?: number;
+}
+export interface ICoreMailModels {
+    State: typeof CoreMailStateDoc;
+    DesiredSnapshot: typeof CoreMailDesiredSnapshotDoc;
+    QuotaCounter: typeof CoreMailQuotaCounterDoc;
+    TransferGrant: typeof CoreMailTransferGrantDoc;
+    Submission: typeof CoreMailSubmissionDoc;
+    InboundDelivery: typeof CoreMailInboundDeliveryDoc;
+    RecipientHandle: typeof CoreMailRecipientHandleDoc;
+    InboundHandoff: typeof CoreMailInboundHandoffDoc;
+}
+export declare const createCoreMailModels: (dbArg: plugins.smartdata.SmartdataDb) => ICoreMailModels;
+export declare const prepareCoreMailModelsForTransactions: (modelsArg: ICoreMailModels) => Promise<void>;
+export {};