@lossless.org/client 1.19.0 → 1.20.1

package/ts/nosqldb/classes.db.ts

@@ -20,6 +20,10 @@ import {
   type ISmartdataNamespaceInspectionOptions,
   type ISmartdataNamespaceInspection,
 } from './classes.namespaceinspection.js';
+import {
+  addSmartdataWriteObserver,
+  type ISmartdataWriteObserverOptions,
+} from './classes.writeobserver.js';
 
 export { SmartdataSession } from './classes.session.js';
 export type {
@@ -27,8 +31,16 @@ export type {
   TSmartdataOrdinarySession,
   TSmartdataTransactionCommitOutcome,
 } from './classes.session.js';
+export type {
+  ISmartdataWriteObserverOptions,
+  ISmartdataWriteReport,
+  TSmartdataObservedFields,
+  TSmartdataObservedValue,
+  TSmartdataWriteKind,
+} from './classes.writeobserver.js';
 
 import { logger } from './logging.js';
+import { buildSmartdataConnectionUrl, redactSmartdataConnectionError } from './connectionstring.js';
 import { assertDataOptions, SmartdataOperationBudget } from './classes.operationbudget.js';
 import {
   composeSmartdataCapabilities,
@@ -247,28 +259,11 @@ export class SmartdataDb {
     try { budget?.check(); } catch (errorArg) { budget?.close(); throw errorArg; }
     this.beginLifecycleOperation('init');
     this.transitionLifecycle('connecting');
+    // Read once, so a failure is redacted with the credentials this attempt connected with.
+    const descriptor = this.smartdataOptions;
     let candidateClient: plugins.mongodb.MongoClient | undefined;
     try {
       try {
-        // Safely encode credentials to handle special characters
-        const encodedUser = this.smartdataOptions.mongoDbUser
-          ? encodeURIComponent(this.smartdataOptions.mongoDbUser)
-          : '';
-        const encodedPass = this.smartdataOptions.mongoDbPass
-          ? encodeURIComponent(this.smartdataOptions.mongoDbPass)
-          : '';
-
-        const finalConnectionUrl = this.smartdataOptions.mongoDbUrl
-          .replace('<USERNAME>', encodedUser)
-          .replace('<username>', encodedUser)
-          .replace('<USER>', encodedUser)
-          .replace('<user>', encodedUser)
-          .replace('<PASSWORD>', encodedPass)
-          .replace('<password>', encodedPass)
-          .replace('<DBNAME>', this.smartdataOptions.mongoDbName || '')
-          .replace('<dbname>', this.smartdataOptions.mongoDbName || '');
-
-        const descriptor = this.smartdataOptions;
         const clientOptions: plugins.mongodb.MongoClientOptions = {
           maxPoolSize: descriptor.maxPoolSize ?? 100,
           maxIdleTimeMS: descriptor.maxIdleTimeMS ?? 300000,
@@ -279,7 +274,8 @@ export class SmartdataDb {
           retryWrites: true,
         };
 
-        candidateClient = new plugins.mongodb.MongoClient(finalConnectionUrl, clientOptions);
+        candidateClient = new plugins.mongodb.MongoClient(
+          buildSmartdataConnectionUrl(descriptor), clientOptions);
         this.pendingClient = candidateClient;
         const connectingClient = candidateClient;
         let cancellationCleanup: Promise<void> | undefined;
@@ -336,9 +332,13 @@ export class SmartdataDb {
             ? 'SmartData connection setup and cleanup failed; close must be retried.'
             : 'SmartData connection setup failed or was cancelled.');
         }
-        if (cleanupError) throw new AggregateError([error, cleanupError],
+        const setupError = new SmartdataPersistenceError('unsupported_operation',
+          'SmartData connection setup failed.',
+          { cause: redactSmartdataConnectionError(error, descriptor) });
+        if (cleanupError) throw new AggregateError(
+          [setupError, redactSmartdataConnectionError(cleanupError, descriptor)],
           'SmartData connection setup and cleanup failed; close must be retried.');
-        throw error;
+        throw setupError;
       }
     } finally {
       this.endLifecycleOperation('init');
@@ -524,6 +524,26 @@ export class SmartdataDb {
     return createSmartdataSession(this);
   }
 
+  /**
+   * Observes every acknowledged write that this process makes through the
+   * database's models: inserts, saves, deletes, atomic and exact writes. Each
+   * write is reported once, after the database acknowledged it; a write inside
+   * a `createSession()` transaction is reported after the commit, and not at
+   * all when the transaction rolls back or its outcome is unknown. A write
+   * that changed nothing (no match, nothing deleted) is not reported. Writes
+   * of other processes, raw driver access and migrations are not observed.
+   *
+   * Reports carry the values of the requested top-level `fields` only, from
+   * the written documents and from the selector's equality conditions. While
+   * an observer is registered, transactions on raw `startSession()` sessions
+   * are refused for model writes, since their outcome is not known here.
+   *
+   * Returns the function that stops the observer.
+   */
+  public observeWrites(optionsArg: ISmartdataWriteObserverOptions): () => void {
+    return addSmartdataWriteObserver(this, optionsArg);
+  }
+
   /**
    * Creates a narrowly scoped MongoDB administration facade bound to this
    * SmartData lifecycle. Applications never need direct driver access.

package/ts/nosqldb/classes.doc.ts

@@ -6851,7 +6851,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
         $set: setObject,
         ...(Object.keys(unsetObject).length > 0 ? { $unset: unsetObject } : {}),
       },
-      { session: options.session, timeoutMS: options.timeoutMS },
+      { session: options.session, timeoutMS: options.timeoutMS, observedDocument: saveableObject },
     );
     if (result.matchedCount === 0) {
       // Nothing was written, so the instance keeps the update timestamp the

package/ts/nosqldb/classes.exactpersistence.ts

@@ -9,6 +9,7 @@ import { registerCollectionReconnectHandler } from './classes.collectionlifecycl
 import type { SmartdataSession } from './classes.session.js';
 import {
   acquireSmartdataSession,
+  reportSmartdataCollectionWrite,
   settleSmartdataOperationError,
   resolveSmartdataOperationDeadline,
 } from './classes.session.js';
@@ -1549,6 +1550,14 @@ export class SmartdataExactCollection<
       }
     }
 
+    /** A reconciled body is this call's own insert only when it carries this call's `_id`. */
+    const reportReconciledInsert = (storedArg: TStoredDocument<TPersisted>): void => {
+      if (storedArg._id.equals(expectedStoredDocument._id)) {
+        reportSmartdataCollectionWrite(
+          this.collection, optionsArg.session, 'insert', [expectedStoredDocument],
+        );
+      }
+    };
     let result: plugins.mongodb.InsertOneResult;
     const insertOptions = { session: sessionArg, ...deadlineArg.commandOptions() };
     try {
@@ -1594,6 +1603,7 @@ export class SmartdataExactCollection<
       }
       if (reconciled) {
         if (bytesEqual(reconciled.bodyBytes, persistedBytes)) {
+          reportReconciledInsert(reconciled.document);
           return { status: 'already_committed', document: reconciled.document };
         }
         if (isDuplicateKeyError(errorArg)) {
@@ -1633,6 +1643,7 @@ export class SmartdataExactCollection<
         );
       }
       if (reconciled && bytesEqual(reconciled.bodyBytes, persistedBytes)) {
+        reportReconciledInsert(reconciled.document);
         return { status: 'already_committed', document: reconciled.document };
       }
       throw this.ambiguousWriteError(
@@ -1640,6 +1651,9 @@ export class SmartdataExactCollection<
         result,
       );
     }
+    reportSmartdataCollectionWrite(
+      this.collection, optionsArg.session, 'insert', [expectedStoredDocument],
+    );
     return { status: 'inserted', document: expectedStoredDocument };
     });
   }
@@ -1827,6 +1841,11 @@ export class SmartdataExactCollection<
       ? { _id: current._id, _smartdataRevision: current._smartdataRevision }
       : { _id: current._id, _smartdataRevision: { $exists: false } };
 
+    const reportTransition = (): void => {
+      reportSmartdataCollectionWrite(
+        this.collection, sessionOptionsArg.session, 'replace', [current, expectedStoredDocument], selector,
+      );
+    };
     const replaceOptions = {
       returnDocument: 'after' as const,
       includeResultMetadata: false as const,
@@ -1851,6 +1870,7 @@ export class SmartdataExactCollection<
           'Exact transition returned a postimage different from the requested state.',
         );
       }
+      reportTransition();
       return { status: 'transitioned', document: expectedStoredDocument };
     } catch (errorArg) {
       if (isTransientTransactionError(errorArg, sessionArg)) {
@@ -1875,6 +1895,7 @@ export class SmartdataExactCollection<
         }, { session: sessionArg, ...deadlineArg.commandOptions() });
         if (reconciledRaw) {
           if (this.encodesAs(reconciledRaw, expectedBytes)) {
+            reportTransition();
             return { status: 'transitioned', document: expectedStoredDocument };
           }
           // A malformed document fails the reconciliation itself.
@@ -1936,6 +1957,9 @@ export class SmartdataExactCollection<
       result.acknowledged === true &&
       result.deletedCount === 1
     ) {
+      reportSmartdataCollectionWrite(
+        this.collection, sessionOptionsArg.session, 'delete', [current], selector,
+      );
       return { status: 'deleted', deletedCount: 1 };
     }
     if (

package/ts/nosqldb/classes.persistence.ts

@@ -78,6 +78,22 @@ export const isMongoTransientTransactionError = (errorArg: unknown): boolean =>
   errorArg instanceof plugins.mongodb.MongoError
   && errorArg.hasErrorLabel(plugins.mongodb.MongoErrorLabel.TransientTransactionError);
 
+/**
+ * The failed operations of a bulk write that failed on write errors. Only then
+ * does the error's result state which operations applied: after a driver or
+ * write-concern error the outcome is unknown and this returns `undefined`.
+ */
+export const getMongoBulkWriteErrorIndexes = (
+  errorArg: unknown,
+): ReadonlySet<number> | undefined => {
+  if (!(errorArg instanceof plugins.mongodb.MongoBulkWriteError)) return undefined;
+  if (errorArg.result?.getWriteConcernError() !== undefined) return undefined;
+  const writeErrors = [errorArg.writeErrors].flat();
+  return writeErrors.length > 0
+    ? new Set(writeErrors.map((writeErrorArg) => writeErrorArg.index))
+    : undefined;
+};
+
 export const isMongoDuplicateKeyError = (
   errorArg: unknown,
 ): errorArg is plugins.mongodb.MongoServerError => {

package/ts/nosqldb/classes.session.ts

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 
+import type { SmartdataCollection } from './classes.collection.js';
 import type { SmartdataDb } from './classes.db.js';
 import {
   SmartdataOperationDeadline,
@@ -15,6 +16,12 @@ import {
   normalizeDeadlineError,
   normalizeOrdinaryPersistenceError,
 } from './classes.persistence.js';
+import {
+  captureSmartdataWrite,
+  hasSmartdataWriteObservers,
+  type ISmartdataWrite,
+  type TSmartdataWriteKind,
+} from './classes.writeobserver.js';
 
 interface ISmartdataSessionBinding {
   session: SmartdataSession;
@@ -36,6 +43,8 @@ interface ISmartdataSessionBinding {
   transactionCommitReached: boolean;
   /** Set when the session ended while a transaction ran, stating how far the transaction had got. */
   transactionEnded?: TSmartdataTransactionEnd;
+  /** The write reports of the current attempt, delivered once the transaction committed. */
+  transactionWrites: Array<() => void>;
   operationSettled?: Promise<void>;
   resolveOperationSettled?: () => void;
   invalidated: boolean;
@@ -307,6 +316,7 @@ export class SmartdataSession {
       binding.transactionUsesOrdinaryWrite = false;
       binding.transactionFailure = undefined;
       binding.transactionCommitReached = false;
+      binding.transactionWrites = [];
       callbackError = undefined;
       attemptInterruption = undefined;
       try {
@@ -435,11 +445,13 @@ export class SmartdataSession {
     };
     let result: TResult | undefined;
     let transactionEnded: TSmartdataTransactionEnd | undefined;
+    let committedWrites: Array<() => void> = [];
     try {
       result = timeoutMS === undefined
         ? await binding.rawSession.withTransaction(runAttempt)
         : await binding.rawSession.withTransaction(runAttempt, { timeoutMS });
       transactionEnded = binding.transactionEnded;
+      committedWrites = binding.transactionWrites;
     } catch (errorArg) {
       const { error, outcome } = settleTransactionRejection(errorArg);
       throw rejectTransaction(error, outcome);
@@ -451,6 +463,7 @@ export class SmartdataSession {
       binding.transactionFailure = undefined;
       binding.transactionCommitReached = false;
       binding.transactionEnded = undefined;
+      binding.transactionWrites = [];
     }
     if (transactionEnded) {
       throw rejectTransaction(
@@ -458,6 +471,9 @@ export class SmartdataSession {
         commitOutcomeOfTransactionEnd(transactionEnded),
       );
     }
+    for (const deliverWrite of committedWrites) {
+      deliverWrite();
+    }
     return result;
   }
 
@@ -495,6 +511,7 @@ export const createSmartdataSession = (ownerArg: SmartdataDb): SmartdataSession
     transactionCallbackOpen: false,
     transactionUsesOrdinaryWrite: false,
     transactionCommitReached: false,
+    transactionWrites: [],
     invalidated: false,
   };
   bindings.set(session, binding);
@@ -656,6 +673,17 @@ export const leaseOrdinarySmartdataSession = (
     if (!optionsArg.prepared && sessionArg?.inTransaction()) {
       refuseUnpreparedCollection(optionsArg, 'inside a transaction');
     }
+    if (
+      optionsArg.ordinaryWrite
+      && sessionArg?.inTransaction()
+      && hasSmartdataWriteObservers(ownerArg)
+    ) {
+      // Only an owned transaction tells SmartData whether it committed.
+      throw new SmartdataPersistenceError(
+        'unsupported_operation',
+        'Writes of an observed database run in transactions of db.createSession(), not raw driver sessions.',
+      );
+    }
     return { rawSession: sessionArg, release: () => {} };
   }
   if (!optionsArg.prepared) {
@@ -753,6 +781,51 @@ export const runWithOrdinarySmartdataSession = async <TResult>(
   }
 };
 
+/**
+ * Reports one acknowledged write to the owner's write observers: at once, or,
+ * inside an owned transaction, after it committed. A transaction that rolls
+ * back, or whose commit outcome is unknown, reports nothing, and a retried
+ * attempt reports only its own writes.
+ */
+export const reportSmartdataWrite = (
+  ownerArg: SmartdataDb,
+  sessionArg: TSmartdataOrdinarySession | undefined,
+  writeArg: ISmartdataWrite,
+): void => {
+  // A raw driver transaction passed its lease while nobody observed, and
+  // whether it commits is never known here.
+  if (!isSmartdataSession(sessionArg) && sessionArg?.inTransaction()) return;
+  const deliver = captureSmartdataWrite(ownerArg, writeArg);
+  if (!deliver) return;
+  const binding = isSmartdataSession(sessionArg) ? bindings.get(sessionArg) : undefined;
+  if (binding?.transactionActive) {
+    // A write that settles after its attempt ended rolls back with that attempt.
+    const attempt = transactionContext.getStore()?.attempt;
+    if (attempt !== undefined && attempt === binding.transactionAttempt) {
+      binding.transactionWrites.push(deliver);
+    }
+    return;
+  }
+  deliver();
+};
+
+/** Reports one acknowledged write of a model collection; see `reportSmartdataWrite`. */
+export const reportSmartdataCollectionWrite = (
+  collectionArg: SmartdataCollection<any>,
+  sessionArg: TSmartdataOrdinarySession | undefined,
+  kindArg: TSmartdataWriteKind,
+  documentsArg: readonly object[] | null,
+  selectorArg?: unknown,
+): void => {
+  reportSmartdataWrite(collectionArg.smartdataDb, sessionArg, {
+    collection: collectionArg.collectionName,
+    kind: kindArg,
+    documents: documentsArg,
+    selector: selectorArg,
+    identityDocumentIdField: collectionArg.getBoundModelSchema()?.identityAsDocumentId,
+  });
+};
+
 /**
  * Ends every session of the owner. `endOptionsArg.timeoutMS` is the driver's
  * deadline for aborting a transaction a session still holds.

package/ts/nosqldb/classes.writeobserver.ts

@@ -0,0 +1,224 @@
+import type { SmartdataDb } from './classes.db.js';
+import { assertDataOptions } from './classes.operationbudget.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+import { logger } from './logging.js';
+
+/** What a write did to its documents. An upsert that inserted is an `insert`. */
+export type TSmartdataWriteKind = 'insert' | 'update' | 'replace' | 'delete';
+
+/** The values a report carries; any other stored value is left out. */
+export type TSmartdataObservedValue = string | number | boolean | null;
+
+/** The observed fields of one document or selector, by field name. */
+export type TSmartdataObservedFields = Readonly<Record<string, TSmartdataObservedValue>>;
+
+/** One acknowledged write, reported to every write observer of its database. */
+export interface ISmartdataWriteReport {
+  /** The collection the write went to. */
+  readonly collection: string;
+  readonly kind: TSmartdataWriteKind;
+  /**
+   * The observed fields of each document the write named or returned: the
+   * inserted documents, a model instance's save or delete, an exact write, the
+   * document a find-one-and-modify returned. `null` when the write addressed
+   * its documents by selector only; `anchors` then says what it pinned.
+   */
+  readonly documents: readonly TSmartdataObservedFields[] | null;
+  /**
+   * The observed fields the write's selector pinned by top-level equality
+   * (`{ field: value }`, `{ field: { $eq: value } }`, or inside `$and`).
+   * Empty for an insert, which has no selector.
+   */
+  readonly anchors: TSmartdataObservedFields;
+}
+
+export interface ISmartdataWriteObserverOptions {
+  /** Top-level field names the reports carry: 1 to 64 distinct names, no `.` and no leading `$`. */
+  fields: readonly string[];
+  /**
+   * Called synchronously once per write. A listener that throws is logged and
+   * never fails the write; one that needs to do async work schedules it.
+   */
+  listener: (reportArg: ISmartdataWriteReport) => void;
+}
+
+/** @internal What a write path states about one acknowledged write. */
+export interface ISmartdataWrite {
+  collection: string;
+  kind: TSmartdataWriteKind;
+  /** The documents as written or returned; `null` for a write by selector only. */
+  documents: readonly object[] | null;
+  selector?: unknown;
+  /** The model's `identityAsDocumentId` field, whose value a selector carries as `_id`. */
+  identityDocumentIdField?: string;
+}
+
+interface IWriteObserver {
+  fields: readonly string[];
+  listener: (reportArg: ISmartdataWriteReport) => void;
+}
+
+const maximumObservedFields = 64;
+const observersByDb = new WeakMap<SmartdataDb, Set<IWriteObserver>>();
+
+const normalizeObserverOptions = (optionsArg: unknown): IWriteObserver => {
+  const { fields, listener } = assertDataOptions(optionsArg, ['fields', 'listener']);
+  if (typeof listener !== 'function') {
+    throw new SmartdataPersistenceError('invalid_argument',
+      'A SmartData write observer requires a listener function.');
+  }
+  if (
+    !Array.isArray(fields)
+    || fields.length === 0
+    || fields.length > maximumObservedFields
+    || fields.some((fieldArg) =>
+      typeof fieldArg !== 'string'
+      || fieldArg.length === 0
+      || fieldArg.includes('.')
+      || fieldArg.startsWith('$'))
+    || new Set(fields).size !== fields.length
+  ) {
+    throw new SmartdataPersistenceError('invalid_argument',
+      `A SmartData write observer requires 1 to ${maximumObservedFields} distinct top-level field names.`);
+  }
+  return {
+    fields: Object.freeze([...fields] as string[]),
+    listener: listener as IWriteObserver['listener'],
+  };
+};
+
+/** @internal Registers a write observer; the returned function removes it. */
+export const addSmartdataWriteObserver = (
+  dbArg: SmartdataDb,
+  optionsArg: ISmartdataWriteObserverOptions,
+): (() => void) => {
+  const observer = normalizeObserverOptions(optionsArg);
+  let observers = observersByDb.get(dbArg);
+  if (!observers) {
+    observers = new Set();
+    observersByDb.set(dbArg, observers);
+  }
+  observers.add(observer);
+  return () => {
+    observersByDb.get(dbArg)?.delete(observer);
+  };
+};
+
+/** @internal */
+export const hasSmartdataWriteObservers = (dbArg: SmartdataDb): boolean =>
+  (observersByDb.get(dbArg)?.size ?? 0) > 0;
+
+const observedValueOf = (valueArg: unknown): TSmartdataObservedValue | undefined =>
+  valueArg === null
+    || typeof valueArg === 'string'
+    || typeof valueArg === 'boolean'
+    || (typeof valueArg === 'number' && Number.isFinite(valueArg))
+    ? valueArg as TSmartdataObservedValue
+    : undefined;
+
+const isPlainRecord = (valueArg: unknown): valueArg is Record<string, unknown> => {
+  if (typeof valueArg !== 'object' || valueArg === null || Array.isArray(valueArg)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(valueArg);
+  return prototype === Object.prototype || prototype === null;
+};
+
+const pickDocumentFields = (
+  documentArg: object,
+  fieldsArg: readonly string[],
+): Record<string, TSmartdataObservedValue> => {
+  const picked: Record<string, TSmartdataObservedValue> = {};
+  for (const field of fieldsArg) {
+    if (!Object.hasOwn(documentArg, field)) continue;
+    const value = observedValueOf((documentArg as Record<string, unknown>)[field]);
+    if (value !== undefined) picked[field] = value;
+  }
+  return picked;
+};
+
+/**
+ * A `null` condition also matches a missing field, so only concrete values
+ * anchor a selector.
+ */
+const collectSelectorAnchors = (
+  selectorArg: unknown,
+  fieldsArg: ReadonlySet<string>,
+  identityDocumentIdFieldArg: string | undefined,
+  anchorsArg: Record<string, TSmartdataObservedValue>,
+): void => {
+  if (!isPlainRecord(selectorArg)) return;
+  for (const key of Object.keys(selectorArg)) {
+    const condition = selectorArg[key];
+    if (key === '$and') {
+      if (Array.isArray(condition)) {
+        for (const conjunct of condition) {
+          collectSelectorAnchors(conjunct, fieldsArg, identityDocumentIdFieldArg, anchorsArg);
+        }
+      }
+      continue;
+    }
+    let value = observedValueOf(condition);
+    if (
+      value === undefined
+      && isPlainRecord(condition)
+      && Object.keys(condition).length === 1
+      && Object.hasOwn(condition, '$eq')
+    ) {
+      value = observedValueOf(condition.$eq);
+    }
+    if (value === undefined || value === null) continue;
+    const fields = key === '_id' && identityDocumentIdFieldArg
+      ? [key, identityDocumentIdFieldArg]
+      : [key];
+    for (const field of fields) {
+      if (fieldsArg.has(field) && !Object.hasOwn(anchorsArg, field)) {
+        anchorsArg[field] = value;
+      }
+    }
+  }
+};
+
+const describeError = (errorArg: unknown): string =>
+  errorArg instanceof Error ? errorArg.message : String(errorArg);
+
+/**
+ * @internal Captures one acknowledged write for the observers registered now,
+ * and returns the delivery, or `undefined` when nobody observes the database.
+ * The observed values are copied at capture, so a delivery deferred to a
+ * transaction's commit reports the write as it was made. An observer removed
+ * before the delivery receives nothing.
+ */
+export const captureSmartdataWrite = (
+  dbArg: SmartdataDb,
+  writeArg: ISmartdataWrite,
+): (() => void) | undefined => {
+  const registered = observersByDb.get(dbArg);
+  if (!registered || registered.size === 0) return undefined;
+  const observers = [...registered];
+  const fields = [...new Set(observers.flatMap((observerArg) => observerArg.fields))];
+  const documents = writeArg.documents?.map((documentArg) =>
+    pickDocumentFields(documentArg, fields)) ?? null;
+  const anchors: Record<string, TSmartdataObservedValue> = {};
+  collectSelectorAnchors(writeArg.selector, new Set(fields), writeArg.identityDocumentIdField, anchors);
+  return () => {
+    for (const observer of observers) {
+      if (!observersByDb.get(dbArg)?.has(observer)) continue;
+      const report: ISmartdataWriteReport = Object.freeze({
+        collection: writeArg.collection,
+        kind: writeArg.kind,
+        documents: documents === null
+          ? null
+          : Object.freeze(documents.map((documentArg) =>
+            Object.freeze(pickDocumentFields(documentArg, observer.fields)))),
+        anchors: Object.freeze(pickDocumentFields(anchors, observer.fields)),
+      });
+      try {
+        observer.listener(report);
+      } catch (errorArg) {
+        logger.log('error',
+          `A SmartData write observer threw on a write to "${writeArg.collection}": ${describeError(errorArg)}`);
+      }
+    }
+  };
+};