@futdevpro/nts-dynamo 1.15.265 → 1.15.266

package/build/_modules/application-alert-delivery/application-alert-delivery.mongo-store.js

@@ -0,0 +1,702 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_ApplicationAlertDelivery_MongoStore = void 0;
+const mongoose_1 = require("mongoose");
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const application_alert_1 = require("@futdevpro/fsm-dynamo/application-alert");
+const application_alert_delivery_state_type_enum_1 = require("./_enums/application-alert-delivery-state.type-enum");
+const DYNTS_APPLICATION_ALERT_DELIVERY_COLLECTION = 'dynts_application_alert_deliveries';
+const dynts_hashPattern = /^[a-f0-9]{64}$/u;
+const dynts_safeSlugPattern = /^[a-z0-9][a-z0-9-]{0,63}$/u;
+const dynts_resultCodePattern = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+){0,15}$/u;
+const dynts_maxCodeLength = 128;
+const dynts_maxRetentionMs = 90 * 24 * 60 * 60 * 1_000;
+const dynts_neverExpires = new Date(8_640_000_000_000_000);
+/** Mongo-backed, explicitly invoked application-alert sender outbox. */
+class DyNTS_ApplicationAlertDelivery_MongoStore {
+    settings;
+    ownedErrors = new WeakSet();
+    isReady = false;
+    readiness;
+    /** Validates finite retry, lease and retention policy without starting any worker or timer. */
+    constructor(settings) {
+        if (!settings?.connection
+            || !dynts_safeSlugPattern.test(settings.sourceSystem)
+            || !this.positiveInteger(settings.maxOperationTimeMs, 60_000)
+            || !this.positiveInteger(settings.leaseDurationMs, 300_000)
+            || settings.leaseDurationMs < 1_000
+            || !this.positiveInteger(settings.maxAttempts, 10)
+            || !Array.isArray(settings.retryBackoffMs)
+            || settings.retryBackoffMs.length !== settings.maxAttempts - 1
+            || !settings.retryBackoffMs.every((value) => (this.positiveInteger(value, 24 * 60 * 60 * 1_000)))
+            || !this.positiveInteger(settings.retentionMs, dynts_maxRetentionMs)) {
+            throw new Error('DyNTS|APPLICATION_ALERT_DELIVERY|INVALID_SETTINGS');
+        }
+        this.settings = Object.freeze({ ...settings, retryBackoffMs: Object.freeze([...settings.retryBackoffMs]) });
+    }
+    /** Creates and verifies the strict collection plus deterministic claim and TTL indexes. */
+    async ensureReady() {
+        this.readiness ??= (async () => {
+            await this.settings.connection.db.createCollection(DYNTS_APPLICATION_ALERT_DELIVERY_COLLECTION, {
+                validator: this.validator(),
+                validationLevel: 'strict',
+                validationAction: 'error',
+            }).catch((error) => {
+                if (!this.isMongoCode(error, 48)) {
+                    throw error;
+                }
+            });
+            const collectionInfo = await this.settings.connection.db.listCollections({ name: DYNTS_APPLICATION_ALERT_DELIVERY_COLLECTION }, { nameOnly: false }).next();
+            if (!(0, node_util_1.isDeepStrictEqual)(collectionInfo?.options?.validator, this.validator())
+                || collectionInfo?.options?.validationLevel !== 'strict'
+                || collectionInfo?.options?.validationAction !== 'error') {
+                throw this.error('SCHEMA_MIGRATION_REQUIRED');
+            }
+            await this.collection().createIndex({ sourceSystem: 1, state: 1, nextAttemptAt: 1, leaseExpiresAt: 1, _id: 1 }, { name: 'dynts_application_alert_delivery_claim_v1', maxTimeMS: this.settings.maxOperationTimeMs });
+            await this.collection().createIndex({ expiresAt: 1 }, {
+                name: 'dynts_application_alert_delivery_expiry_v1',
+                expireAfterSeconds: 0,
+                maxTimeMS: this.settings.maxOperationTimeMs,
+            });
+            this.isReady = true;
+        })().catch((error) => {
+            this.readiness = undefined;
+            this.isReady = false;
+            if (error instanceof Error && this.ownedErrors.has(error)) {
+                throw error;
+            }
+            throw this.error('NOT_READY', error);
+        });
+        await this.readiness;
+    }
+    /** Inserts one validated envelope or acknowledges an exact idempotent replay. */
+    async schedule(value) {
+        return this.protect('SCHEDULE_FAILED', async () => {
+            this.assertReady();
+            const validation = application_alert_1.DyFM_ApplicationAlertEnvelope_Util.validate(value);
+            if (!validation.valid || !validation.envelope || !validation.payloadChecksum
+                || validation.envelope.sourceSystem !== this.settings.sourceSystem) {
+                throw this.error('ENVELOPE_INVALID');
+            }
+            const envelope = validation.envelope;
+            const key = this.key(envelope.sourceSystem, envelope.idempotencyKey);
+            const existing = await this.collection().findOne({ _id: key }, this.options());
+            if (existing) {
+                this.assertReplay(existing, envelope, validation.payloadChecksum);
+                return this.view(existing, false);
+            }
+            const now = await this.databaseTime();
+            const record = {
+                _id: key,
+                contractVersion: 'dynts-application-alert-delivery/1',
+                sourceSystem: envelope.sourceSystem,
+                idempotencyKey: envelope.idempotencyKey,
+                payloadChecksum: validation.payloadChecksum,
+                envelope: envelope,
+                state: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.pending,
+                attemptCount: 0,
+                fencingToken: 0,
+                claimTokenHash: '',
+                claimedAt: new Date(0),
+                leaseExpiresAt: new Date(0),
+                nextAttemptAt: now,
+                lastOutcome: '',
+                lastResultCode: '',
+                deliveryReference: '',
+                createdAt: now,
+                updatedAt: now,
+                completedAt: new Date(0),
+                expiresAt: new Date(dynts_neverExpires.getTime()),
+            };
+            try {
+                await this.collection().insertOne(record, this.options());
+            }
+            catch (error) {
+                if (!this.isMongoCode(error, 11000)) {
+                    throw error;
+                }
+                const raced = await this.collection().findOne({ _id: key }, this.options());
+                if (!raced) {
+                    throw this.error('IDEMPOTENCY_RACE');
+                }
+                this.assertReplay(raced, envelope, validation.payloadChecksum);
+                return this.view(raced, false);
+            }
+            return this.view(record, true);
+        });
+    }
+    /** Claims at most one due item or retires one exhausted crashed claim; it never waits or polls. */
+    async claimNext() {
+        return this.protect('CLAIM_FAILED', async () => {
+            this.assertReady();
+            const retired = await this.retireExhausted();
+            if (retired) {
+                this.assertRecord(retired);
+                return Object.freeze({
+                    contractVersion: 'dynts-application-alert-claim/1',
+                    code: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertInvocationCode_Type.terminalFailureRecorded,
+                    claimed: false,
+                    claimToken: '',
+                    fencingToken: retired.fencingToken,
+                    delivery: this.view(retired, true),
+                });
+            }
+            const claimToken = (0, node_crypto_1.randomBytes)(32).toString('hex');
+            const claimTokenHash = this.tokenHash(claimToken);
+            const claimed = await this.collection().findOneAndUpdate({
+                sourceSystem: this.settings.sourceSystem,
+                attemptCount: { $lt: this.settings.maxAttempts },
+                $or: [
+                    {
+                        state: { $in: [
+                                application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.pending,
+                                application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.retryWaiting,
+                            ] },
+                        $expr: { $lte: ['$nextAttemptAt', '$$NOW'] },
+                    },
+                    {
+                        state: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching,
+                        $expr: { $lte: ['$leaseExpiresAt', '$$NOW'] },
+                    },
+                ],
+            }, [{ $set: {
+                        state: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching,
+                        attemptCount: { $add: ['$attemptCount', 1] },
+                        fencingToken: { $add: ['$fencingToken', 1] },
+                        claimTokenHash: { $literal: claimTokenHash },
+                        claimedAt: '$$NOW',
+                        leaseExpiresAt: { $dateAdd: {
+                                startDate: '$$NOW', unit: 'millisecond', amount: this.settings.leaseDurationMs,
+                            } },
+                        updatedAt: '$$NOW',
+                    } }], {
+                ...this.options(),
+                sort: { nextAttemptAt: 1, _id: 1 },
+                returnDocument: 'after',
+                includeResultMetadata: false,
+            });
+            if (!claimed) {
+                return Object.freeze({
+                    contractVersion: 'dynts-application-alert-claim/1',
+                    code: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertInvocationCode_Type.noReadyDelivery,
+                    claimed: false,
+                    claimToken: '',
+                    fencingToken: 0,
+                });
+            }
+            this.assertRecord(claimed);
+            return Object.freeze({
+                contractVersion: 'dynts-application-alert-claim/1',
+                code: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertInvocationCode_Type.deliveryClaimed,
+                claimed: true,
+                claimToken: claimToken,
+                fencingToken: claimed.fencingToken,
+                envelope: this.copyEnvelope(claimed.envelope),
+                delivery: this.view(claimed, true),
+            });
+        });
+    }
+    /** Commits accepted, retryable or terminal delivery evidence under the live DB-time fence. */
+    async complete(value) {
+        return this.protect('COMPLETE_FAILED', async () => {
+            this.assertReady();
+            const completion = this.completion(value);
+            const key = this.key(completion.sourceSystem, completion.idempotencyKey);
+            const current = await this.collection().findOne({ _id: key }, this.options());
+            if (!current) {
+                throw this.error('NOT_FOUND');
+            }
+            this.assertRecord(current);
+            const tokenHash = this.tokenHash(completion.claimToken);
+            if (current.state !== application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching) {
+                if (this.isExactCompletionReplay(current, completion, tokenHash)) {
+                    return this.view(current, false);
+                }
+                throw this.error('FENCE_LOST');
+            }
+            if (current.fencingToken !== completion.fencingToken || current.claimTokenHash !== tokenHash) {
+                throw this.error('FENCE_LOST');
+            }
+            const retry = completion.submission.outcome
+                === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.retryableFailure
+                && current.attemptCount < this.settings.maxAttempts;
+            const terminalState = completion.submission.outcome
+                === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.accepted
+                ? application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.succeeded
+                : application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.failed;
+            const nextState = retry
+                ? application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.retryWaiting
+                : terminalState;
+            const backoffMs = retry ? this.settings.retryBackoffMs[current.attemptCount - 1] : 0;
+            const updated = await this.collection().findOneAndUpdate({
+                _id: key,
+                sourceSystem: completion.sourceSystem,
+                idempotencyKey: completion.idempotencyKey,
+                state: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching,
+                fencingToken: completion.fencingToken,
+                claimTokenHash: tokenHash,
+                $expr: { $gt: ['$leaseExpiresAt', '$$NOW'] },
+            }, [{ $set: {
+                        state: nextState,
+                        leaseExpiresAt: new Date(0),
+                        nextAttemptAt: retry ? { $dateAdd: {
+                                startDate: '$$NOW', unit: 'millisecond', amount: backoffMs,
+                            } } : '$$NOW',
+                        lastOutcome: completion.submission.outcome,
+                        lastResultCode: completion.submission.resultCode,
+                        deliveryReference: completion.submission.deliveryReference,
+                        updatedAt: '$$NOW',
+                        completedAt: retry ? new Date(0) : '$$NOW',
+                        expiresAt: retry ? dynts_neverExpires : { $dateAdd: {
+                                startDate: '$$NOW', unit: 'millisecond', amount: this.settings.retentionMs,
+                            } },
+                    } }], { ...this.options(), returnDocument: 'after', includeResultMetadata: false });
+            if (!updated) {
+                throw this.error('FENCE_LOST');
+            }
+            this.assertRecord(updated);
+            return this.view(updated, true);
+        });
+    }
+    /** Reads only within the configured source-system boundary. */
+    async read(idempotencyKey) {
+        return this.protect('READ_FAILED', async () => {
+            this.assertReady();
+            if (!dynts_hashPattern.test(idempotencyKey)) {
+                throw this.error('IDENTITY_INVALID');
+            }
+            const record = await this.collection().findOne({ _id: this.key(this.settings.sourceSystem, idempotencyKey) }, this.options());
+            if (!record) {
+                return null;
+            }
+            this.assertRecord(record);
+            return this.view(record, false);
+        });
+    }
+    /** Returns bounded aggregate delivery health without returning any alert or receiver content. */
+    async inspect() {
+        return this.protect('INSPECTION_FAILED', async () => {
+            this.assertReady();
+            const openStates = [
+                application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.pending,
+                application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching,
+                application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.retryWaiting,
+            ];
+            const rows = await this.collection().aggregate([
+                { $match: { sourceSystem: this.settings.sourceSystem } },
+                { $group: {
+                        _id: null,
+                        pendingCount: { $sum: { $cond: [
+                                    { $eq: ['$state', application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.pending] }, 1, 0,
+                                ] } },
+                        dispatchingCount: { $sum: { $cond: [
+                                    { $eq: ['$state', application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching] }, 1, 0,
+                                ] } },
+                        retryWaitingCount: { $sum: { $cond: [
+                                    { $eq: ['$state', application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.retryWaiting] }, 1, 0,
+                                ] } },
+                        succeededCount: { $sum: { $cond: [
+                                    { $eq: ['$state', application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.succeeded] }, 1, 0,
+                                ] } },
+                        failedCount: { $sum: { $cond: [
+                                    { $eq: ['$state', application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.failed] }, 1, 0,
+                                ] } },
+                        dueCount: { $sum: { $cond: [{ $or: [
+                                            { $and: [
+                                                    { $in: ['$state', [
+                                                                application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.pending,
+                                                                application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.retryWaiting,
+                                                            ]] },
+                                                    { $lte: ['$nextAttemptAt', '$$NOW'] },
+                                                ] },
+                                            { $and: [
+                                                    { $eq: ['$state', application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching] },
+                                                    { $lte: ['$leaseExpiresAt', '$$NOW'] },
+                                                ] },
+                                        ] }, 1, 0] } },
+                        expiredLeaseCount: { $sum: { $cond: [{ $and: [
+                                            { $eq: ['$state', application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching] },
+                                            { $lte: ['$leaseExpiresAt', '$$NOW'] },
+                                        ] }, 1, 0] } },
+                        oldestOpenAt: { $min: { $cond: [
+                                    { $in: ['$state', openStates] }, '$createdAt', new Date(dynts_neverExpires.getTime()),
+                                ] } },
+                    } },
+            ], this.options()).toArray();
+            const row = rows[0];
+            const observedAt = await this.databaseTime();
+            if (rows.length > 1 || (row && (!this.aggregateCount(row.pendingCount)
+                || !this.aggregateCount(row.dispatchingCount) || !this.aggregateCount(row.retryWaitingCount)
+                || !this.aggregateCount(row.succeededCount) || !this.aggregateCount(row.failedCount)
+                || !this.aggregateCount(row.dueCount) || !this.aggregateCount(row.expiredLeaseCount)
+                || !this.date(row.oldestOpenAt)))) {
+                throw this.error('INSPECTION_INVALID');
+            }
+            return Object.freeze({
+                contractVersion: 'dynts-application-alert-operations/1',
+                sourceSystem: this.settings.sourceSystem,
+                pendingCount: Number(row?.pendingCount ?? 0),
+                dispatchingCount: Number(row?.dispatchingCount ?? 0),
+                retryWaitingCount: Number(row?.retryWaitingCount ?? 0),
+                succeededCount: Number(row?.succeededCount ?? 0),
+                failedCount: Number(row?.failedCount ?? 0),
+                dueCount: Number(row?.dueCount ?? 0),
+                expiredLeaseCount: Number(row?.expiredLeaseCount ?? 0),
+                oldestOpenAt: row?.oldestOpenAt instanceof Date && row.oldestOpenAt.getTime() !== dynts_neverExpires.getTime()
+                    ? row.oldestOpenAt.toISOString() : '',
+                observedAt: observedAt.toISOString(),
+            });
+        });
+    }
+    async retireExhausted() {
+        return this.collection().findOneAndUpdate({
+            sourceSystem: this.settings.sourceSystem,
+            state: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching,
+            attemptCount: { $gte: this.settings.maxAttempts },
+            $expr: { $lte: ['$leaseExpiresAt', '$$NOW'] },
+        }, [{ $set: {
+                    state: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.failed,
+                    leaseExpiresAt: new Date(0),
+                    nextAttemptAt: '$$NOW',
+                    lastOutcome: application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.terminalFailure,
+                    lastResultCode: 'LEASE_EXPIRED_AFTER_FINAL_ATTEMPT',
+                    deliveryReference: '',
+                    updatedAt: '$$NOW',
+                    completedAt: '$$NOW',
+                    expiresAt: { $dateAdd: {
+                            startDate: '$$NOW', unit: 'millisecond', amount: this.settings.retentionMs,
+                        } },
+                } }], {
+            ...this.options(),
+            sort: { leaseExpiresAt: 1, _id: 1 },
+            returnDocument: 'after',
+            includeResultMetadata: false,
+        });
+    }
+    completion(value) {
+        if (!this.exactRecord(value, [
+            'contractVersion', 'sourceSystem', 'idempotencyKey', 'fencingToken', 'claimToken', 'submission',
+        ])) {
+            throw this.error('COMPLETION_INVALID');
+        }
+        const submission = this.submission(value.submission);
+        if (value.contractVersion !== 'dynts-application-alert-completion/1'
+            || value.sourceSystem !== this.settings.sourceSystem
+            || typeof value.idempotencyKey !== 'string'
+            || !dynts_hashPattern.test(value.idempotencyKey)
+            || !Number.isSafeInteger(value.fencingToken)
+            || Number(value.fencingToken) < 1
+            || typeof value.claimToken !== 'string'
+            || !dynts_hashPattern.test(value.claimToken)) {
+            throw this.error('COMPLETION_INVALID');
+        }
+        return Object.freeze({
+            contractVersion: 'dynts-application-alert-completion/1',
+            sourceSystem: value.sourceSystem,
+            idempotencyKey: value.idempotencyKey,
+            fencingToken: Number(value.fencingToken),
+            claimToken: value.claimToken,
+            submission: submission,
+        });
+    }
+    submission(value) {
+        if (!this.exactRecord(value, ['contractVersion', 'outcome', 'resultCode', 'deliveryReference'])) {
+            throw this.error('SUBMISSION_INVALID');
+        }
+        const outcome = this.submissionOutcome(value.outcome);
+        if (value.contractVersion !== 'dynts-application-alert-submission/1'
+            || !outcome
+            || typeof value.resultCode !== 'string'
+            || !dynts_resultCodePattern.test(value.resultCode)
+            || value.resultCode.length > dynts_maxCodeLength
+            || typeof value.deliveryReference !== 'string'
+            || (outcome === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.accepted
+                ? !dynts_hashPattern.test(value.deliveryReference)
+                : value.deliveryReference !== '')) {
+            throw this.error('SUBMISSION_INVALID');
+        }
+        return Object.freeze({
+            contractVersion: 'dynts-application-alert-submission/1',
+            outcome: outcome,
+            resultCode: value.resultCode,
+            deliveryReference: value.deliveryReference,
+        });
+    }
+    submissionOutcome(value) {
+        if (value === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.accepted
+            || value === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.retryableFailure
+            || value === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.terminalFailure) {
+            return value;
+        }
+        return null;
+    }
+    isExactCompletionReplay(record, completion, tokenHash) {
+        return record.fencingToken === completion.fencingToken
+            && record.claimTokenHash === tokenHash
+            && record.lastOutcome === completion.submission.outcome
+            && record.lastResultCode === completion.submission.resultCode
+            && record.deliveryReference === completion.submission.deliveryReference;
+    }
+    assertReplay(record, envelope, payloadChecksum) {
+        this.assertRecord(record);
+        if (record.sourceSystem !== envelope.sourceSystem
+            || record.idempotencyKey !== envelope.idempotencyKey
+            || record.payloadChecksum !== payloadChecksum) {
+            throw this.error('IDENTITY_PAYLOAD_CONFLICT');
+        }
+    }
+    assertRecord(record) {
+        const validation = application_alert_1.DyFM_ApplicationAlertEnvelope_Util.validate(record?.envelope);
+        if (!this.exactRecord(record, [
+            '_id', 'contractVersion', 'sourceSystem', 'idempotencyKey', 'payloadChecksum', 'envelope', 'state',
+            'attemptCount', 'fencingToken', 'claimTokenHash', 'claimedAt', 'leaseExpiresAt', 'nextAttemptAt',
+            'lastOutcome', 'lastResultCode', 'deliveryReference', 'createdAt', 'updatedAt', 'completedAt', 'expiresAt',
+        ])
+            || record.contractVersion !== 'dynts-application-alert-delivery/1'
+            || record._id !== this.key(record.sourceSystem, record.idempotencyKey)
+            || record.sourceSystem !== this.settings.sourceSystem
+            || !dynts_hashPattern.test(record.idempotencyKey)
+            || !dynts_hashPattern.test(record.payloadChecksum)
+            || !validation.valid
+            || validation.payloadChecksum !== record.payloadChecksum
+            || validation.envelope?.sourceSystem !== record.sourceSystem
+            || validation.envelope?.idempotencyKey !== record.idempotencyKey
+            || !this.deliveryState(record.state)
+            || !Number.isSafeInteger(record.attemptCount)
+            || record.attemptCount < 0
+            || record.attemptCount > this.settings.maxAttempts
+            || !Number.isSafeInteger(record.fencingToken)
+            || record.fencingToken < 0
+            || (record.claimTokenHash !== '' && !/^sha256:[a-f0-9]{64}$/u.test(record.claimTokenHash))
+            || !this.date(record.claimedAt)
+            || !this.date(record.leaseExpiresAt)
+            || !this.date(record.nextAttemptAt)
+            || !this.lastOutcome(record.lastOutcome)
+            || (record.lastResultCode !== '' && !dynts_resultCodePattern.test(record.lastResultCode))
+            || record.lastResultCode.length > dynts_maxCodeLength
+            || (record.deliveryReference !== '' && !dynts_hashPattern.test(record.deliveryReference))
+            || !this.date(record.createdAt)
+            || !this.date(record.updatedAt)
+            || !this.date(record.completedAt)
+            || !this.date(record.expiresAt)
+            || record.updatedAt.getTime() < record.createdAt.getTime()
+            || !this.recordStateValid(record)) {
+            throw this.error('INVALID_RECORD');
+        }
+    }
+    recordStateValid(record) {
+        const zero = 0;
+        const never = dynts_neverExpires.getTime();
+        const hasClaim = /^sha256:[a-f0-9]{64}$/u.test(record.claimTokenHash)
+            && record.attemptCount >= 1
+            && record.fencingToken === record.attemptCount
+            && record.claimedAt.getTime() >= record.createdAt.getTime();
+        if (record.state === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.pending) {
+            return record.attemptCount === 0 && record.fencingToken === 0 && record.claimTokenHash === ''
+                && record.claimedAt.getTime() === zero && record.leaseExpiresAt.getTime() === zero
+                && record.lastOutcome === '' && record.lastResultCode === '' && record.deliveryReference === ''
+                && record.completedAt.getTime() === zero && record.expiresAt.getTime() === never;
+        }
+        if (!hasClaim) {
+            return false;
+        }
+        if (record.state === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching) {
+            const priorOutcomeValid = (record.lastOutcome === '' && record.lastResultCode === '')
+                || (record.lastOutcome === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.retryableFailure
+                    && record.lastResultCode !== '');
+            return record.leaseExpiresAt.getTime() > record.claimedAt.getTime()
+                && priorOutcomeValid && record.deliveryReference === ''
+                && record.completedAt.getTime() === zero && record.expiresAt.getTime() === never;
+        }
+        if (record.leaseExpiresAt.getTime() !== zero || record.lastResultCode === '') {
+            return false;
+        }
+        if (record.state === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.retryWaiting) {
+            return record.attemptCount < this.settings.maxAttempts
+                && record.lastOutcome === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.retryableFailure
+                && record.deliveryReference === '' && record.nextAttemptAt.getTime() > record.updatedAt.getTime()
+                && record.completedAt.getTime() === zero && record.expiresAt.getTime() === never;
+        }
+        const terminalTimeValid = record.completedAt.getTime() === record.updatedAt.getTime()
+            && record.expiresAt.getTime() > record.completedAt.getTime();
+        if (record.state === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.succeeded) {
+            return terminalTimeValid
+                && record.lastOutcome === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.accepted
+                && dynts_hashPattern.test(record.deliveryReference);
+        }
+        return terminalTimeValid
+            && (record.lastOutcome === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.retryableFailure
+                || record.lastOutcome === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type.terminalFailure)
+            && record.deliveryReference === '';
+    }
+    copyEnvelope(envelope) {
+        const validation = application_alert_1.DyFM_ApplicationAlertEnvelope_Util.validate(envelope);
+        if (!validation.valid || !validation.envelope) {
+            throw this.error('INVALID_RECORD');
+        }
+        return validation.envelope;
+    }
+    view(record, changed) {
+        this.assertRecord(record);
+        return Object.freeze({
+            contractVersion: 'dynts-application-alert-delivery-view/1',
+            sourceSystem: record.sourceSystem,
+            idempotencyKey: record.idempotencyKey,
+            payloadChecksum: record.payloadChecksum,
+            state: record.state,
+            attemptCount: record.attemptCount,
+            fencingToken: record.fencingToken,
+            lastOutcome: record.lastOutcome,
+            lastResultCode: record.lastResultCode,
+            deliveryReference: record.deliveryReference,
+            createdAt: record.createdAt.toISOString(),
+            updatedAt: record.updatedAt.toISOString(),
+            completedAt: record.completedAt.getTime() === 0 ? '' : record.completedAt.toISOString(),
+            changed: changed,
+        });
+    }
+    deliveryState(value) {
+        return value === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.pending
+            || value === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.dispatching
+            || value === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.retryWaiting
+            || value === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.succeeded
+            || value === application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type.failed;
+    }
+    lastOutcome(value) {
+        return value === '' || this.submissionOutcome(value) !== null;
+    }
+    exactRecord(value, expectedKeys) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            return false;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        const keys = Reflect.ownKeys(value);
+        return (prototype === Object.prototype || prototype === null)
+            && keys.length === expectedKeys.length
+            && keys.every((key) => {
+                const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                return typeof key === 'string'
+                    && expectedKeys.includes(key)
+                    && !!descriptor
+                    && Object.hasOwn(descriptor, 'value')
+                    && descriptor.enumerable === true;
+            });
+    }
+    key(sourceSystem, idempotencyKey) {
+        return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify([
+            'dynts-application-alert-delivery/1', sourceSystem, idempotencyKey,
+        ])).digest('hex');
+    }
+    tokenHash(token) {
+        return `sha256:${(0, node_crypto_1.createHash)('sha256').update(token).digest('hex')}`;
+    }
+    async databaseTime() {
+        const result = await this.settings.connection.db.command({ hello: 1, maxTimeMS: this.settings.maxOperationTimeMs }, { timeoutMS: this.settings.maxOperationTimeMs });
+        if (!(result.localTime instanceof Date) || !Number.isFinite(result.localTime.getTime())) {
+            throw this.error('CLOCK_UNAVAILABLE');
+        }
+        return result.localTime;
+    }
+    positiveInteger(value, maximum) {
+        return Number.isSafeInteger(value) && Number(value) > 0 && Number(value) <= maximum;
+    }
+    aggregateCount(value) {
+        return Number.isSafeInteger(value) && Number(value) >= 0;
+    }
+    date(value) {
+        return value instanceof Date && Number.isFinite(value.getTime());
+    }
+    collection() {
+        return this.settings.connection.db.collection(DYNTS_APPLICATION_ALERT_DELIVERY_COLLECTION);
+    }
+    options() {
+        return { maxTimeMS: this.settings.maxOperationTimeMs };
+    }
+    assertReady() {
+        if (!this.isReady) {
+            throw this.error('NOT_READY');
+        }
+    }
+    async protect(code, task) {
+        try {
+            return await task();
+        }
+        catch (error) {
+            if (error instanceof Error && this.ownedErrors.has(error)) {
+                throw error;
+            }
+            throw this.error(code, error);
+        }
+    }
+    error(code, cause) {
+        const error = cause === undefined
+            ? new Error(`DyNTS|APPLICATION_ALERT_DELIVERY|${code}`)
+            : new Error(`DyNTS|APPLICATION_ALERT_DELIVERY|${code}`, { cause: cause });
+        this.ownedErrors.add(error);
+        return error;
+    }
+    isMongoCode(error, code) {
+        return error instanceof mongoose_1.mongo.MongoServerError && error.code === code;
+    }
+    validator() {
+        const hash = { bsonType: 'string', pattern: '^[a-f0-9]{64}$' };
+        const utc = { bsonType: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}T.*\\.\\d{3}Z$' };
+        const evidence = { bsonType: 'object', additionalProperties: false,
+            required: ['code', 'value'], properties: {
+                code: {
+                    bsonType: 'string', pattern: '^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+){0,15}$', maxLength: dynts_maxCodeLength,
+                },
+                value: { bsonType: ['int', 'long', 'double'], minimum: 0, maximum: Number.MAX_SAFE_INTEGER },
+            } };
+        const envelope = { bsonType: 'object', additionalProperties: false, required: [
+                'contractVersion', 'sourceSystem', 'environment', 'sourceRevision', 'imageDigest', 'alertCode', 'severity',
+                'observedAt', 'windowStartedAt', 'windowEndedAt', 'policyVersion', 'evaluationState', 'evidence',
+                'idempotencyKey',
+            ], properties: {
+                contractVersion: { enum: ['dyfm-application-alert/1'] },
+                sourceSystem: { bsonType: 'string', pattern: '^[a-z0-9][a-z0-9-]{0,63}$' },
+                environment: { bsonType: 'string', pattern: '^[a-z0-9][a-z0-9-]{0,63}$' },
+                sourceRevision: { bsonType: 'string', pattern: '^[a-f0-9]{40}$' },
+                imageDigest: { bsonType: 'string', pattern: '^sha256:[a-f0-9]{64}$' },
+                alertCode: {
+                    bsonType: 'string', pattern: '^[A-Z][A-Z0-9]*(?:-[A-Z0-9]+){2,15}$', maxLength: dynts_maxCodeLength,
+                },
+                severity: { enum: ['low', 'medium', 'high', 'critical'] },
+                observedAt: utc, windowStartedAt: utc, windowEndedAt: utc,
+                policyVersion: { bsonType: 'string', pattern: '^[a-z0-9][a-z0-9-]{1,63}/[1-9][0-9]{0,8}$' },
+                evaluationState: { enum: ['active', 'resolved'] },
+                evidence: { bsonType: 'array', minItems: 1, maxItems: 16, uniqueItems: true, items: evidence },
+                idempotencyKey: hash,
+            } };
+        const properties = {
+            _id: hash,
+            contractVersion: { enum: ['dynts-application-alert-delivery/1'] },
+            sourceSystem: { bsonType: 'string', pattern: '^[a-z0-9][a-z0-9-]{0,63}$' },
+            idempotencyKey: hash,
+            payloadChecksum: hash,
+            envelope: envelope,
+            state: { enum: Object.values(application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertDeliveryState_Type) },
+            attemptCount: { bsonType: ['int', 'long', 'double'], minimum: 0, maximum: 10 },
+            fencingToken: { bsonType: ['int', 'long', 'double'], minimum: 0, maximum: Number.MAX_SAFE_INTEGER },
+            claimTokenHash: { bsonType: 'string', pattern: '^(?:|sha256:[a-f0-9]{64})$' },
+            claimedAt: { bsonType: 'date' },
+            leaseExpiresAt: { bsonType: 'date' },
+            nextAttemptAt: { bsonType: 'date' },
+            lastOutcome: { enum: ['', ...Object.values(application_alert_delivery_state_type_enum_1.DyNTS_ApplicationAlertSubmissionOutcome_Type)] },
+            lastResultCode: {
+                bsonType: 'string', pattern: '^(?:|[A-Z][A-Z0-9]*(?:_[A-Z0-9]+){0,15})$',
+                maxLength: dynts_maxCodeLength,
+            },
+            deliveryReference: { bsonType: 'string', pattern: '^(?:|[a-f0-9]{64})$' },
+            createdAt: { bsonType: 'date' },
+            updatedAt: { bsonType: 'date' },
+            completedAt: { bsonType: 'date' },
+            expiresAt: { bsonType: 'date' },
+        };
+        return { $jsonSchema: { bsonType: 'object', additionalProperties: false,
+                required: Object.keys(properties), properties: properties } };
+    }
+}
+exports.DyNTS_ApplicationAlertDelivery_MongoStore = DyNTS_ApplicationAlertDelivery_MongoStore;
+//# sourceMappingURL=application-alert-delivery.mongo-store.js.map