@serve.zone/dcrouter 32.1.1 → 32.1.3

package/ts/email/classes.smartmta-storage-manager.ts

@@ -1,9 +1,9 @@
-import * as plugins from '../plugins.js';
 import type {
   IStorageManager,
   IStorageListPageOptions,
   IStorageListPageResult,
 } from '@push.rocks/smartmta';
+import { SmartMtaStorageDoc } from '../db/documents/classes.smartmta-storage.doc.js';
 import {
   getSmartMtaTextNamespace,
   hashSmartMtaStorageKey,
@@ -11,46 +11,45 @@ import {
   validateSmartMtaTextValue,
 } from './smartmta-storage-policy.js';
 
-interface ISmartMtaStorageDocument {
-  _id: string;
-  id: string;
-  key: string;
-  value: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
+/**
+ * SmartMTA's key/value storage, backed by the content-addressed `SmartMtaStorageDoc`.
+ *
+ * The document model declares `identityAsDocumentId: 'id'`, so the `sha256(normalizedKey)`
+ * identity is the stored `_id`: every read and write below pins `id` by equality and is
+ * answered through the primary key, which is what makes `set()` one race-free upsert
+ * without a secondary unique index. The model owns its database binding, so this manager
+ * holds no connection and no collection handle of its own.
+ */
 export class SmartMtaStorageManager implements IStorageManager {
-  private readonly collection: any;
-
-  constructor(smartdataDb: plugins.smartdata.SmartdataDb) {
-    this.collection = smartdataDb.mongoDb.collection('SmartMtaStorageDoc');
-  }
-
+  /**
+   * A stored document is only usable when it still carries the content address it was
+   * written under. `_id` is not re-read here: it equals `id` by construction — an
+   * identity-pinned upsert derives the inserted `_id` from its own filter, and the client
+   * refuses to store a document whose `_id` diverges from its declared identity.
+   */
   private validateDocument(
-    document: ISmartMtaStorageDocument,
-    expectedKey?: string,
-  ): ISmartMtaStorageDocument {
-    const normalizedKey = normalizeSmartMtaStorageKey(document.key);
+    documentArg: SmartMtaStorageDoc,
+    expectedKeyArg?: string,
+  ): SmartMtaStorageDoc {
+    const normalizedKey = normalizeSmartMtaStorageKey(documentArg.key);
     const expectedId = hashSmartMtaStorageKey(normalizedKey);
     if (
-      document._id !== expectedId
-      || document.id !== expectedId
-      || document.key !== normalizedKey
-      || (expectedKey && document.key !== expectedKey)
-      || typeof document.value !== 'string'
+      documentArg.id !== expectedId
+      || documentArg.key !== normalizedKey
+      || (expectedKeyArg && documentArg.key !== expectedKeyArg)
+      || typeof documentArg.value !== 'string'
     ) {
-      throw new Error(`Corrupt SmartMTA storage document: ${document._id}`);
+      throw new Error(`Corrupt SmartMTA storage document: ${documentArg.id}`);
     }
-    validateSmartMtaTextValue(document.key, document.value);
-    return document;
+    validateSmartMtaTextValue(documentArg.key, documentArg.value);
+    return documentArg;
   }
 
   public async get(key: string): Promise<string | null> {
     const normalizedKey = normalizeSmartMtaStorageKey(key);
     getSmartMtaTextNamespace(normalizedKey);
     const id = hashSmartMtaStorageKey(normalizedKey);
-    const document = await this.collection.findOne({ _id: id });
+    const document = await SmartMtaStorageDoc.getInstance<SmartMtaStorageDoc>({ id });
     return document ? this.validateDocument(document, normalizedKey).value : null;
   }
 
@@ -58,17 +57,21 @@ export class SmartMtaStorageManager implements IStorageManager {
     const normalizedKey = normalizeSmartMtaStorageKey(key);
     validateSmartMtaTextValue(normalizedKey, value);
     const id = hashSmartMtaStorageKey(normalizedKey);
-    const existing = await this.collection.findOne({ _id: id });
+    const existing = await SmartMtaStorageDoc.getInstance<SmartMtaStorageDoc>({ id });
     if (existing) {
       this.validateDocument(existing, normalizedKey);
     }
 
     const now = new Date().toISOString();
-    await this.collection.updateOne(
-      { _id: id },
+    // The equality anchor on `id` is mandatory for an upsert on this model: MongoDB derives
+    // the inserted primary key from the filter, and the client refuses an unpinned upsert
+    // rather than let a generated `_id` contradict the declared identity. It seeds `id`
+    // itself from that anchor, so the value never has to be repeated in `$setOnInsert` —
+    // and may not be, because `$set` can never modify an immutable `@unI()` field.
+    await SmartMtaStorageDoc.atomicUpdate<SmartMtaStorageDoc>(
+      { id },
       {
         $set: {
-          id,
           key: normalizedKey,
           value,
           updatedAt: now,
@@ -80,7 +83,7 @@ export class SmartMtaStorageManager implements IStorageManager {
       { upsert: true },
     );
 
-    const stored = await this.collection.findOne({ _id: id });
+    const stored = await SmartMtaStorageDoc.getInstance<SmartMtaStorageDoc>({ id });
     if (!stored || this.validateDocument(stored, normalizedKey).value !== value) {
       throw new Error(`SmartMTA storage write verification failed: ${normalizedKey}`);
     }
@@ -89,16 +92,22 @@ export class SmartMtaStorageManager implements IStorageManager {
   public async list(prefix: string): Promise<string[]> {
     const normalizedPrefix = normalizeSmartMtaStorageKey(prefix);
     getSmartMtaTextNamespace(normalizedPrefix);
-    const documents = await this.collection.find({
+    const cursor = await SmartMtaStorageDoc.getCursor<SmartMtaStorageDoc>({
       key: {
         $gte: normalizedPrefix,
-        $lt: `${normalizedPrefix}\uffff`,
+        $lt: `${normalizedPrefix}￿`,
       },
-    }).toArray();
+    });
+    let documents: SmartMtaStorageDoc[];
+    try {
+      documents = await cursor.toArray();
+    } finally {
+      await cursor.close();
+    }
 
     return documents
-      .map((document: ISmartMtaStorageDocument) => this.validateDocument(document).key)
-      .filter((key: string) => key.startsWith(normalizedPrefix))
+      .map((documentArg) => this.validateDocument(documentArg).key)
+      .filter((keyArg) => keyArg.startsWith(normalizedPrefix))
       .sort();
   }
 
@@ -126,24 +135,29 @@ export class SmartMtaStorageManager implements IStorageManager {
       seekAfter = decoded;
     }
 
-    const documents = await this.collection
-      .find({
+    const cursor = await SmartMtaStorageDoc.getCursor<SmartMtaStorageDoc>(
+      {
         key: {
           ...(seekAfter ? { $gt: seekAfter } : { $gte: normalizedPrefix }),
           $lt: `${normalizedPrefix}￿`,
         },
-      })
-      .sort({ key: 1 })
-      .limit(limit + 1)
-      .toArray();
+      },
+      { sort: { key: 1 }, limit: limit + 1 },
+    );
+    let documents: SmartMtaStorageDoc[];
+    try {
+      documents = await cursor.toArray();
+    } finally {
+      await cursor.close();
+    }
 
     const hasMore = documents.length > limit;
     const pageDocuments = documents.slice(0, limit);
     const keys = pageDocuments
-      .map((document: ISmartMtaStorageDocument) => this.validateDocument(document).key)
-      .filter((key: string) => key.startsWith(normalizedPrefix));
+      .map((documentArg) => this.validateDocument(documentArg).key)
+      .filter((keyArg) => keyArg.startsWith(normalizedPrefix));
     const lastKey = pageDocuments.length > 0
-      ? (pageDocuments[pageDocuments.length - 1] as ISmartMtaStorageDocument).key
+      ? pageDocuments[pageDocuments.length - 1].key
       : undefined;
 
     return {
@@ -158,10 +172,12 @@ export class SmartMtaStorageManager implements IStorageManager {
     const normalizedKey = normalizeSmartMtaStorageKey(key);
     getSmartMtaTextNamespace(normalizedKey);
     const id = hashSmartMtaStorageKey(normalizedKey);
-    const existing = await this.collection.findOne({ _id: id });
+    const existing = await SmartMtaStorageDoc.getInstance<SmartMtaStorageDoc>({ id });
     if (existing) {
       this.validateDocument(existing, normalizedKey);
-      await this.collection.deleteOne({ _id: id });
+      // The identity pins a single document, which is what the client requires of a
+      // singular delete; the primary key answers it.
+      await SmartMtaStorageDoc.atomicDelete<SmartMtaStorageDoc>({ id });
     }
   }
 }

package/ts/security/classes.security-policy-manager.ts

@@ -296,13 +296,13 @@ export class SecurityPolicyManager {
     const expiryCutoff = this.now() - IP_INTELLIGENCE_RETENTION_MAX_AGE_MS;
 
     while (!this.isStopping) {
-      const expiredIds = await IpIntelligenceDoc.findOldestIds({
+      const expiredIpAddresses = await IpIntelligenceDoc.findOldestIpAddresses({
         lastSeenBefore: expiryCutoff,
         limit: IP_INTELLIGENCE_RETENTION_BATCH_SIZE,
       });
-      if (expiredIds.length === 0) break;
-      deletedCount += await IpIntelligenceDoc.deleteByDocumentIds(expiredIds);
-      if (expiredIds.length < IP_INTELLIGENCE_RETENTION_BATCH_SIZE) break;
+      if (expiredIpAddresses.length === 0) break;
+      deletedCount += await IpIntelligenceDoc.deleteByIpAddresses(expiredIpAddresses);
+      if (expiredIpAddresses.length < IP_INTELLIGENCE_RETENTION_BATCH_SIZE) break;
     }
 
     let currentCount = await IpIntelligenceDoc.countAll();
@@ -315,13 +315,15 @@ export class SecurityPolicyManager {
           remainingToDelete,
           IP_INTELLIGENCE_RETENTION_BATCH_SIZE,
         );
-        const oldestIds = await IpIntelligenceDoc.findOldestIds({ limit: batchLimit });
-        if (oldestIds.length === 0) break;
-        const deletedThisBatch = await IpIntelligenceDoc.deleteByDocumentIds(oldestIds);
+        const oldestIpAddresses = await IpIntelligenceDoc.findOldestIpAddresses({
+          limit: batchLimit,
+        });
+        if (oldestIpAddresses.length === 0) break;
+        const deletedThisBatch = await IpIntelligenceDoc.deleteByIpAddresses(oldestIpAddresses);
         deletedCount += deletedThisBatch;
         currentCount -= deletedThisBatch;
         remainingToDelete -= deletedThisBatch;
-        if (deletedThisBatch === 0 || oldestIds.length < batchLimit) break;
+        if (deletedThisBatch === 0 || oldestIpAddresses.length < batchLimit) break;
       }
     }