@lossless.org/client 1.20.1 → 1.21.0

package/ts/nosqldb/classes.atomicupdate.ts

@@ -57,6 +57,7 @@ export const executeAtomicUpdate = async <T>(
             result.upsertedCount > 0 ? 'insert' : 'update',
             optsArg?.observedDocument ? [optsArg.observedDocument] : null,
             filterArg,
+            { images: 'none', update: updateArg },
           );
         }
         return result;
@@ -122,6 +123,7 @@ export const executeAtomicUpsertMany = async <T>(
             Object.hasOwn(upsertedIdsArg ?? {}, indexArg) ? 'insert' : 'update',
             null,
             operationArg.filter,
+            { images: 'none', update: operationArg.update },
           );
         });
       };
@@ -206,7 +208,14 @@ export const executeAtomicUpdateMany = async <T>(
           },
         );
         if (result.matchedCount > 0) {
-          reportSmartdataCollectionWrite(collectionArg, optsArg?.session, 'update', null, filterArg);
+          reportSmartdataCollectionWrite(
+            collectionArg,
+            optsArg?.session,
+            'update',
+            null,
+            filterArg,
+            { images: 'none', update: updateArg },
+          );
         }
         return result;
       } catch (errorArg) {

package/ts/nosqldb/classes.bootstraprecord.ts

@@ -6,7 +6,8 @@ import { snapshotBoundedBsonDocument } from './classes.bsonsnapshot.js';
 import { validateOrdinaryStoredDocument } from './classes.ordinarypersistence.js';
 import { SmartdataPersistenceError, isMongoDuplicateKeyError } from './classes.persistence.js';
 import { readBoundedInspectionCursor } from './classes.namespaceinspection.js';
-import { reportSmartdataWrite } from './classes.session.js';
+import { reportSmartdataWrite, reportSmartdataWriteFailure } from './classes.session.js';
+import { runSmartdataWrite } from './classes.readtracker.js';
 import {
   collectionModelSchemaResolverSymbol, collectionTopologyDbInspectionSymbol,
   getExpectedCollectionTopologyForSchema, inspectCollectionTopologySnapshot,
@@ -63,7 +64,7 @@ export const insertBootstrapRecord = async (
     let outcome: TBootstrapOutcome;
     try {
       // Explicit preparation uses this same connection-generation guard.
-      outcome = await dbArg[collectionTopologyDbInspectionSymbol](async (mongoDbArg, assertCurrentArg) => {
+      outcome = await runSmartdataWrite(dbArg, () => dbArg[collectionTopologyDbInspectionSymbol](async (mongoDbArg, assertCurrentArg) => {
         budget.check();
         const namespaces = await readBoundedInspectionCursor(mongoDbArg.listCollections(
           { name: schema.collectionName },
@@ -91,18 +92,20 @@ export const insertBootstrapRecord = async (
         } catch (errorArg) {
           return isMongoDuplicateKeyError(errorArg) ? 'unique_conflict' : 'ambiguous_write';
         }
-      });
+      }));
     } catch {
+      if (dispatched) reportSmartdataWriteFailure(dbArg, undefined, schema.collectionName);
       throw new SmartdataPersistenceError(dispatched ? 'ambiguous_write' : 'unsupported_operation',
         dispatched ? 'Bootstrap insertion outcome is uncertain; inspect its explicit ID before proceeding.'
           : 'Bootstrap insertion could not inspect the current database connection.');
     }
     if (outcome === 'inserted') {
       reportSmartdataWrite(dbArg, undefined, {
-        collection: schema.collectionName, kind: 'insert', documents: [document],
+        collection: schema.collectionName, kind: 'insert', documents: [document], images: 'after',
       });
       return Object.freeze({ acknowledged: true, insertedId: document._id as string });
     }
+    if (outcome === 'ambiguous_write') reportSmartdataWriteFailure(dbArg, undefined, schema.collectionName);
     const messages = {
       unique_conflict: 'Bootstrap record conflicts with a unique index.',
       invalid_configuration: 'Bootstrap insertion requires absent or exact primary-only collection topology.',

package/ts/nosqldb/classes.collection.ts

@@ -35,6 +35,7 @@ import {
   leaseOrdinarySmartdataSession,
   reportSmartdataCollectionWrite,
   runWithOrdinarySmartdataSession,
+  trackSmartdataRead,
   type TSmartdataOrdinarySession,
 } from './classes.session.js';
 import {
@@ -1842,14 +1843,16 @@ const indexEquivalenceSignature = (indexArg: {
   });
 
 /**
- * MongoDB reports an index collision without naming the index already in the
- * namespace, yet the remedy depends on it: adopt that name in the declaration
- * or drop the index. Only the collision path pays for the extra catalog read.
+ * MongoDB reports an index collision without naming either index, yet the
+ * remedy depends on them: adopt the existing name in the declaration or drop
+ * the index. The declarations are checked in order against the catalog and
+ * against one another, since one command creates them all. Only the collision
+ * path pays for the extra catalog read.
  */
 const describeIndexCollision = async (
   targetCollectionArg: plugins.mongodb.Collection,
   collectionNameArg: string,
-  expectedArg: INormalizedCollectionModelSchema['indexes'][number],
+  expectedIndexesArg: INormalizedCollectionModelSchema['indexes'],
   errorArg: unknown,
 ): Promise<unknown> => {
   if (!isMongoIndexConflictError(errorArg)) {
@@ -1863,31 +1866,49 @@ const describeIndexCollision = async (
     // own error stays the best evidence the caller can act on.
     return errorArg;
   }
-  const equivalentIndex = actualIndexes.find(
-    (actualArg) =>
-      actualArg.name !== expectedArg.name &&
-      stableValue(Object.entries(actualArg.key || {})) ===
-        stableValue(expectedArg.key) &&
-      indexEquivalenceSignature(actualArg) ===
-        indexEquivalenceSignature(expectedArg.options),
-  );
-  if (equivalentIndex) {
-    return new SmartdataPersistenceError(
-      'invalid_configuration',
-      `Collection "${collectionNameArg}" already carries the equivalent index ` +
-        `"${equivalentIndex.name}", so declared index "${expectedArg.name}" ` +
-        'cannot be created. Declare the existing name — an identity declares ' +
-        'it with @unI({ indexName }) — or drop the existing index.',
-      { cause: errorArg },
-    );
-  }
-  if (actualIndexes.some((actualArg) => actualArg.name === expectedArg.name)) {
-    return new SmartdataPersistenceError(
-      'invalid_configuration',
-      `Collection "${collectionNameArg}" already carries an index named ` +
-        `"${expectedArg.name}" with a different key or options.`,
-      { cause: errorArg },
+  for (const [position, expected] of expectedIndexesArg.entries()) {
+    const equivalentIndex = actualIndexes.find(
+      (actualArg) =>
+        actualArg.name !== expected.name &&
+        stableValue(Object.entries(actualArg.key || {})) ===
+          stableValue(expected.key) &&
+        indexEquivalenceSignature(actualArg) ===
+          indexEquivalenceSignature(expected.options),
     );
+    if (equivalentIndex) {
+      return new SmartdataPersistenceError(
+        'invalid_configuration',
+        `Collection "${collectionNameArg}" already carries the equivalent index ` +
+          `"${equivalentIndex.name}", so declared index "${expected.name}" ` +
+          'cannot be created. Declare the existing name — an identity declares ' +
+          'it with @unI({ indexName }) — or drop the existing index.',
+        { cause: errorArg },
+      );
+    }
+    if (actualIndexes.some((actualArg) => actualArg.name === expected.name)) {
+      return new SmartdataPersistenceError(
+        'invalid_configuration',
+        `Collection "${collectionNameArg}" already carries an index named ` +
+          `"${expected.name}" with a different key or options.`,
+        { cause: errorArg },
+      );
+    }
+    const equivalentDeclaration = expectedIndexesArg
+      .slice(0, position)
+      .find(
+        (earlierArg) =>
+          stableValue(earlierArg.key) === stableValue(expected.key) &&
+          indexEquivalenceSignature(earlierArg.options) ===
+            indexEquivalenceSignature(expected.options),
+      );
+    if (equivalentDeclaration) {
+      return new SmartdataPersistenceError(
+        'invalid_configuration',
+        `Collection "${collectionNameArg}" declares the equivalent indexes ` +
+          `"${equivalentDeclaration.name}" and "${expected.name}"; declare one name.`,
+        { cause: errorArg },
+      );
+    }
   }
   // An index over the same key that is not interchangeable with the
   // declaration cannot be adopted by name, and MongoDB's own error already
@@ -2133,20 +2154,22 @@ export class SmartdataCollection<T> {
     if (!modelSchema) {
       return;
     }
-    for (const index of modelSchema.indexes) {
+    // One command for every declared index: the server builds the missing
+    // ones together, or none of them when one collides.
+    if (modelSchema.indexes.length > 0) {
       try {
-        await targetCollection.createIndex(
-          Object.fromEntries(index.key) as plugins.mongodb.IndexSpecification,
-          {
+        await targetCollection.createIndexes(
+          modelSchema.indexes.map((index) => ({
             ...index.options,
+            key: Object.fromEntries(index.key) as plugins.mongodb.IndexDescription['key'],
             name: index.name,
-          },
+          })),
         );
       } catch (errorArg) {
         throw await describeIndexCollision(
           targetCollection,
           this.collectionName,
-          index,
+          modelSchema.indexes,
           errorArg,
         );
       }
@@ -2400,12 +2423,20 @@ export class SmartdataCollection<T> {
       { ordinaryWrite: false, timeoutMS: opts?.timeoutMS },
       async (rawSessionArg, deadlineArg) => {
         await deadlineArg.join(this.init());
-        return this.mongoDbCollection.findOne(filterObject, {
+        const tracked = trackSmartdataRead(this, opts?.session, {
+          kind: 'documents',
+          filter: filterObject,
+          limited: true,
+        });
+        const document = await this.mongoDbCollection.findOne(filterObject, {
           projection: opts?.projection,
           maxTimeMS: opts?.maxTimeMS,
           session: rawSessionArg,
           ...deadlineArg.commandOptions(),
         });
+        if (document) tracked?.record(document);
+        tracked?.settle();
+        return document;
       },
     );
   }
@@ -2426,10 +2457,14 @@ export class SmartdataCollection<T> {
     });
     try {
       await this.init();
+      const tracked = trackSmartdataRead(this, opts?.session, {
+        kind: 'documents',
+        filter: filterObjectArg,
+      });
       const cursor = this.mongoDbCollection.find(filterObjectArg, {
         session: lease.rawSession,
       });
-      return new SmartdataDbCursor(cursor, dbDocArg, lease.release);
+      return new SmartdataDbCursor(cursor, dbDocArg, lease.release, tracked);
     } catch (cursorCreationError) {
       lease.release();
       throw cursorCreationError;
@@ -2448,6 +2483,10 @@ export class SmartdataCollection<T> {
       { ordinaryWrite: false, timeoutMS: opts?.timeoutMS },
       async (rawSessionArg, deadlineArg) => {
         await deadlineArg.join(this.init());
+        const tracked = trackSmartdataRead(this, opts?.session, {
+          kind: 'documents',
+          filter: filterObject,
+        });
         const cursor = this.mongoDbCollection.find(filterObject, {
           session: rawSessionArg,
           ...deadlineArg.cursorOptions(),
@@ -2460,6 +2499,10 @@ export class SmartdataCollection<T> {
           (cursorArg) => cursorArg.toArray(),
           deadlineArg.signal,
         );
+        if (tracked) {
+          for (const document of result) tracked.record(document);
+          tracked.settle();
+        }
 
         // In-memory check for duplicate _id values (should never happen)
         if (result.length > 0) {
@@ -2603,7 +2646,9 @@ export class SmartdataCollection<T> {
             ...deadlineArg.commandOptions(),
           });
           if (result.acknowledged) {
-            reportSmartdataCollectionWrite(this, opts?.session, 'insert', [saveableObject]);
+            reportSmartdataCollectionWrite(
+              this, opts?.session, 'insert', [saveableObject], undefined, { images: 'after' },
+            );
           }
           return result;
         } catch (err: any) {
@@ -2646,6 +2691,12 @@ export class SmartdataCollection<T> {
       { ordinaryWrite: false, timeoutMS: opts?.timeoutMS, signal: opts?.signal },
       async (rawSessionArg, deadlineArg) => {
         await deadlineArg.join(this.init());
+        // Totals depend on every matching document, not on which ones come back.
+        trackSmartdataRead(this, opts?.session, {
+          kind: 'documents',
+          filter: matchArg ?? {},
+          matches: true,
+        });
         const pipeline: plugins.mongodb.Document[] = [];
         if (matchArg && Object.keys(matchArg).length > 0) {
           pipeline.push({ $match: matchArg });
@@ -2719,7 +2770,9 @@ export class SmartdataCollection<T> {
             .map((indexArg) => saveableObjects[Number(indexArg)])
             .filter((documentArg) => documentArg !== undefined);
           if (inserted.length > 0) {
-            reportSmartdataCollectionWrite(this, opts?.session, 'insert', inserted);
+            reportSmartdataCollectionWrite(
+              this, opts?.session, 'insert', inserted, undefined, { images: 'after' },
+            );
           }
         };
         try {
@@ -2784,7 +2837,9 @@ export class SmartdataCollection<T> {
           .map((indexArg) => prepared[Number(indexArg)])
           .filter((documentArg) => documentArg !== undefined);
         if (inserted.length > 0) {
-          reportSmartdataCollectionWrite(this, optsArg.session, 'insert', inserted);
+          reportSmartdataCollectionWrite(
+            this, optsArg.session, 'insert', inserted, undefined, { images: 'after' },
+          );
         }
       };
       try {
@@ -2859,15 +2914,16 @@ export class SmartdataCollection<T> {
           }
           updateableObject[key] = saveableObject[key];
         }
+        const update = {
+          $set: updateableObject,
+          ...(Object.keys(insertOnlyObject).length > 0
+            ? { $setOnInsert: insertOnlyObject }
+            : {}),
+        };
         try {
           const result = await this.mongoDbCollection.updateOne(
             identifiableObject,
-            {
-              $set: updateableObject,
-              ...(Object.keys(insertOnlyObject).length > 0
-                ? { $setOnInsert: insertOnlyObject }
-                : {}),
-            },
+            update,
             { upsert: true, session: rawSessionArg, ...deadlineArg.commandOptions() },
           );
           if (result.upsertedCount > 0 || result.matchedCount > 0) {
@@ -2877,6 +2933,7 @@ export class SmartdataCollection<T> {
               result.upsertedCount > 0 ? 'insert' : 'update',
               [saveableObject],
               identifiableObject,
+              { images: 'none', update },
             );
           }
           return result;
@@ -2917,6 +2974,7 @@ export class SmartdataCollection<T> {
             'delete',
             observedDocument ? [observedDocument] : null,
             identifiableObject,
+            { images: 'none' },
           );
         }
         return result;
@@ -2968,6 +3026,11 @@ export class SmartdataCollection<T> {
       { ordinaryWrite: false, timeoutMS: opts?.timeoutMS, signal: opts?.signal },
       async (rawSessionArg, deadlineArg) => {
         await deadlineArg.join(this.init());
+        const tracked = trackSmartdataRead(this, opts?.session, {
+          kind: 'count',
+          filter: filterObject,
+          hint: opts?.hint,
+        });
         const pipeline: plugins.mongodb.Document[] = [{ $match: filterObject }];
         if (opts?.limit !== undefined) {
           pipeline.push({ $limit: opts.limit });
@@ -2979,9 +3042,11 @@ export class SmartdataCollection<T> {
           ...deadlineArg.commandOptions(),
           session: rawSessionArg,
         });
-        return runCursorOperation(cursor, async (cursorArg) =>
+        const count = await runCursorOperation(cursor, async (cursorArg) =>
           (await cursorArg.next())?.count ?? 0,
         deadlineArg.signal);
+        tracked?.settle();
+        return count;
       },
     );
   }
@@ -3043,6 +3108,7 @@ export class SmartdataCollection<T> {
     duplicateFields: Array<{ field: string; duplicateValues: number }>;
   }> {
     await this.init();
+    trackSmartdataRead(this, undefined, { kind: 'collection' });
     const result = {
       ok: true,
       estimatedCount: 0,

package/ts/nosqldb/classes.cursor.ts

@@ -1,4 +1,5 @@
 import { SmartDataDbDoc } from './classes.doc.js';
+import type { ISmartdataReadRecorder } from './classes.readtracker.js';
 import * as plugins from './plugins.js';
 
 /**
@@ -16,14 +17,23 @@ export class SmartdataDbCursor<T = any> {
    * raw driver session or no session at all.
    */
   private releaseSession: () => void;
+  /** Records the read for open read sets; it settles once the cursor is exhausted. */
+  private readRecorder?: ISmartdataReadRecorder;
   constructor(
     cursorArg: plugins.mongodb.FindCursor<T>,
     dbDocArg: typeof SmartDataDbDoc,
     releaseSessionArg: () => void = () => {},
+    readRecorderArg?: ISmartdataReadRecorder,
   ) {
-    this.mongodbCursor = cursorArg;
+    this.mongodbCursor = readRecorderArg
+      ? cursorArg.map((documentArg) => {
+        readRecorderArg.record(documentArg);
+        return documentArg;
+      })
+      : cursorArg;
     this.smartdataDbDoc = dbDocArg;
     this.releaseSession = releaseSessionArg;
+    this.readRecorder = readRecorderArg;
   }
 
   public async next(closeAtEnd = true): Promise<T | null> {
@@ -34,6 +44,7 @@ export class SmartdataDbCursor<T = any> {
       return await this.closeAfterError(readError);
     }
     if (nextDocument === null) {
+      this.readRecorder?.settle();
       if (closeAtEnd) {
         await this.close();
       }
@@ -59,6 +70,7 @@ export class SmartdataDbCursor<T = any> {
           await forEachFuncArg(nextClassInstance as any);
         }
       } while (nextDocument);
+      this.readRecorder?.settle();
     } catch (iterationError) {
       if (closeCursorAtEnd) {
         await this.closeAfterError(iterationError);
@@ -74,6 +86,7 @@ export class SmartdataDbCursor<T = any> {
     let convertedResult: T[];
     try {
       const result = await this.mongodbCursor.toArray();
+      this.readRecorder?.settle();
       convertedResult = result.map((itemArg) =>
         this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(itemArg),
       ) as T[];

package/ts/nosqldb/classes.db.ts

@@ -24,8 +24,15 @@ import {
   addSmartdataWriteObserver,
   type ISmartdataWriteObserverOptions,
 } from './classes.writeobserver.js';
+import {
+  changeSmartdataReadSetsOfDb,
+  trackSmartdataReads,
+  type ISmartdataTrackedReads,
+} from './classes.readtracker.js';
 
 export { SmartdataSession } from './classes.session.js';
+export { SmartdataReadSet } from './classes.readtracker.js';
+export type { ISmartdataTrackedReads } from './classes.readtracker.js';
 export type {
   ISmartdataTransactionOptions,
   TSmartdataOrdinarySession,
@@ -358,6 +365,7 @@ export class SmartdataDb {
     this.beginLifecycleOperation('close');
     this.transitionLifecycle('closing');
     this.status = 'disconnected';
+    changeSmartdataReadSetsOfDb(this);
     const mongoDbClient = this.pendingClient ?? this.mongoDbClient;
     try {
       const closeErrors: unknown[] = [];
@@ -544,6 +552,30 @@ export class SmartdataDb {
     return addSmartdataWriteObserver(this, optionsArg);
   }
 
+  /**
+   * Runs `fnArg` and records every model read it makes on this database:
+   * `findOne`, `findAll`, `getCursor`, counts, pages and the exact reads.
+   * Each read is kept as its query and the ids it returned. The returned
+   * `reads.changed` turns true once a write this process makes through the
+   * database's models could have changed any of those results; a write it
+   * cannot place, such as an update by a selector it cannot evaluate, counts
+   * as one that did. A cache keyed by `reads` rebuilds only what such a write
+   * touched.
+   *
+   * Writes of other processes, raw driver access and migrations are not
+   * followed. A read inside a transaction, a read of another database and a
+   * write made inside `fnArg` mark the set changed at once. Queries are
+   * evaluated by MongoDB's simple binary comparison, so a read of a view or of
+   * a collection with a default collation marks the set changed as well; each
+   * read collection is checked once per connection when `fnArg` returns.
+   * Close a set that is no longer needed.
+   */
+  public async trackReads<TResult>(
+    fnArg: () => TResult | Promise<TResult>,
+  ): Promise<ISmartdataTrackedReads<TResult>> {
+    return trackSmartdataReads(this, fnArg);
+  }
+
   /**
    * Creates a narrowly scoped MongoDB administration facade bound to this
    * SmartData lifecycle. Applications never need direct driver access.

package/ts/nosqldb/classes.doc.ts

@@ -43,6 +43,7 @@ import {
   isOrdinarySessionInTransaction,
   leaseOrdinarySmartdataSession,
   runWithOrdinarySmartdataSession,
+  trackSmartdataRead,
   type TSmartdataOrdinarySession,
 } from './classes.session.js';
 import {
@@ -6055,24 +6056,39 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       timeoutMS,
     }, async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collection.init());
+      const sort = { [optionsArg.sortField]: sortDirection, [uniqueField]: sortDirection } as const;
+      const tracked = trackSmartdataRead(collection, optionsArg.session, {
+        kind: 'documents',
+        filter: selector,
+        sort,
+        limited: true,
+      });
       const rawCursor = collection.mongoDbCollection
         .find(selector, { session: rawSessionArg, ...deadlineArg.cursorOptions() })
-        .sort({ [optionsArg.sortField]: sortDirection, [uniqueField]: sortDirection })
+        .sort(sort)
         .limit(limit + 1);
       return runCursorOperation(rawCursor, async (cursorArg) => {
         const rawDocuments = await cursorArg.toArray();
+        if (tracked) {
+          for (const rawDocument of rawDocuments) tracked.record(rawDocument);
+          tracked.settle();
+        }
         const hasMore = rawDocuments.length > limit;
         const pageRows = rawDocuments.slice(0, limit);
         const documents = pageRows.map(
           (rawDocument: any) => (this as any).createInstanceFromMongoDbNativeDoc(rawDocument) as T,
         );
         const lastRow: any = pageRows[pageRows.length - 1];
+        const countTracked = optionsArg.withTotal
+          ? trackSmartdataRead(collection, optionsArg.session, { kind: 'count', filter: baseSelector })
+          : undefined;
         const total = optionsArg.withTotal
           ? await collection.mongoDbCollection.countDocuments(baseSelector, {
               session: rawSessionArg,
               ...deadlineArg.commandOptions(),
             })
           : undefined;
+        countTracked?.settle();
         return {
           documents,
           ...(hasMore && lastRow
@@ -6211,8 +6227,14 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     });
     try {
       await collection.init();
+      const filter = (this as any).normalizeReadFilter(filterArg);
+      // A modifier changes the query in ways a read set cannot follow, and a
+      // skipped page depends on the documents before it.
+      const tracked = trackSmartdataRead(collection, session, modifier
+        ? { kind: 'collection' }
+        : { kind: 'documents', filter, sort, hint, matches: skip !== undefined && skip > 0, limited: Boolean(limit) });
       let rawCursor: plugins.mongodb.FindCursor<any> =
-        collection.mongoDbCollection.find((this as any).normalizeReadFilter(filterArg), {
+        collection.mongoDbCollection.find(filter, {
           projection,
           session: lease.rawSession,
           hint,
@@ -6261,6 +6283,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
         rawCursor,
         this as any as typeof SmartDataDbDoc,
         lease.release,
+        tracked,
       );
     } catch (cursorCreationError) {
       lease.release();
@@ -6309,12 +6332,19 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
       defaultTimeoutMS: 5_000,
       signal: opts.signal,
     }, async (rawSessionArg, deadlineArg) => {
+      const tracked = trackSmartdataRead(collection, opts.session, {
+        kind: 'documents', filter, sort, hint, matches: skip > 0, limited: true,
+      });
       const rawCursor = collection.mongoDbCollection.find(filter, {
         projection, sort, hint, skip, limit, maxTimeMS,
         ...deadlineArg.cursorOptions(), session: rawSessionArg,
       });
       return runCursorOperation(rawCursor, async (cursorArg) => {
         const documents = await cursorArg.toArray();
+        if (tracked) {
+          for (const document of documents) tracked.record(document);
+          tracked.settle();
+        }
         return documents.map((documentArg) =>
           (this as any).createInstanceFromMongoDbNativeDoc(documentArg) as T,
         );