liwi-mongo 13.4.0 → 14.1.0

package/dist/definitions/memory/normalizeSort.d.ts

@@ -0,0 +1,4 @@
+import type { Sort } from "mongodb";
+/** The driver's sort shapes as one `{ field: 1 | -1 }`, in order. */
+export declare const normalizeSort: (sort: Sort) => Record<string, -1 | 1>;
+//# sourceMappingURL=normalizeSort.d.ts.map

package/dist/definitions/memory/normalizeSort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeSort.d.ts","sourceRoot":"","sources":["../../../src/memory/normalizeSort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAiB,MAAM,SAAS,CAAC;AAgDnD,qEAAqE;AACrE,eAAO,MAAM,aAAa,SAAU,IAAI,KAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAM7D,CAAC"}

package/dist/definitions/memory/normalizeSort.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=normalizeSort.test.d.ts.map

package/dist/definitions/memory/normalizeSort.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeSort.test.d.ts","sourceRoot":"","sources":["../../../src/memory/normalizeSort.test.ts"],"names":[],"mappings":""}

package/dist/definitions/memory/queryOptions.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from "mingo/types";
+export declare const queryOptions: Partial<Options>;
+//# sourceMappingURL=queryOptions.d.ts.map

package/dist/definitions/memory/queryOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryOptions.d.ts","sourceRoot":"","sources":["../../../src/memory/queryOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,OAAO,CAAoB,CAAC"}

package/dist/definitions/memory/serializeKey.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Same string for values mongo considers the same key: canonical extended JSON
+ * keeps types apart (`"1"` and `1`, a `Date` and its timestamp).
+ */
+export declare const serializeKey: (value: unknown) => string;
+//# sourceMappingURL=serializeKey.d.ts.map

package/dist/definitions/memory/serializeKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeKey.d.ts","sourceRoot":"","sources":["../../../src/memory/serializeKey.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,YAAY,UAAW,OAAO,KAAG,MAGmB,CAAC"}

package/dist/definitions/memory/settle.d.ts

@@ -0,0 +1,3 @@
+/** Runs `run` now, its throw as a rejection: driver methods never throw synchronously. */
+export declare const settle: <Result>(run: () => Result) => Promise<Result>;
+//# sourceMappingURL=settle.d.ts.map

package/dist/definitions/memory/settle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle.d.ts","sourceRoot":"","sources":["../../../src/memory/settle.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,eAAO,MAAM,MAAM,GAAI,MAAM,OAAO,MAAM,MAAM,KAAG,OAAO,CAAC,MAAM,CAG7D,CAAC"}

package/dist/definitions/memory.d.ts

@@ -0,0 +1,2 @@
+export { createMemoryMongoClient, type MemoryMongoClient, type MemoryMongoClientOptions, } from "./memory/createMemoryMongoClient.ts";
+//# sourceMappingURL=memory.d.ts.map

package/dist/definitions/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,GAC9B,MAAM,qCAAqC,CAAC"}

package/dist/definitions/writes/createReplacePipeline.d.ts

@@ -0,0 +1,10 @@
+import type { Document } from "mongodb";
+import type { MongoBaseModel } from "../MongoBaseModel.ts";
+/**
+ * Replaces the stored document with `replacement` while keeping the stored `created`
+ * (falling back to the replacement's when the stored document has none).
+ * `$literal` keeps string values starting with `$` from being read as field paths.
+ * Update pipelines require MongoDB >= 4.2.
+ */
+export declare const createReplacePipeline: (replacement: MongoBaseModel<any>) => Document[];
+//# sourceMappingURL=createReplacePipeline.d.ts.map

package/dist/definitions/writes/createReplacePipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createReplacePipeline.d.ts","sourceRoot":"","sources":["../../../src/writes/createReplacePipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,gBACnB,cAAc,CAAC,GAAG,CAAC,KAC/B,QAAQ,EAWV,CAAC"}

package/dist/definitions/writes/stampPartialUpdate.d.ts

@@ -0,0 +1,9 @@
+import type { BaseModel, Update } from "liwi-store";
+/**
+ * Throws `ProtectedFieldUpdateError` when the update touches `created`, or touches
+ * `updated` with an operator other than `$set`, `$currentDate` or `$max`.
+ * Otherwise returns the update with `updated` set to `now`, unless the caller sets
+ * `updated` itself or `now` is `undefined`. The caller's update is never mutated.
+ */
+export declare const stampPartialUpdate: <Model extends BaseModel>(update: Update<Model>, now: Date | undefined) => Update<Model>;
+//# sourceMappingURL=stampPartialUpdate.d.ts.map

package/dist/definitions/writes/stampPartialUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stampPartialUpdate.d.ts","sourceRoot":"","sources":["../../../src/writes/stampPartialUpdate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAoEpD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,SAAS,SAAS,UAChD,MAAM,CAAC,KAAK,CAAC,OAChB,IAAI,GAAG,SAAS,KACpB,MAAM,CAAC,KAAK,CAKd,CAAC"}

package/dist/definitions/writes/stampPartialUpdate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stampPartialUpdate.test.d.ts.map

package/dist/definitions/writes/stampPartialUpdate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stampPartialUpdate.test.d.ts","sourceRoot":"","sources":["../../../src/writes/stampPartialUpdate.test.ts"],"names":[],"mappings":""}

package/dist/index-node.mjs

@@ -1,5 +1,5 @@
+import { AbstractStoreCursor, ProtectedFieldUpdateError, NotFoundError, AbstractConnection } from 'liwi-store';
 import mongodb from 'mongodb';
-import { AbstractStoreCursor, AbstractConnection } from 'liwi-store';
 import { AbstractSubscribableStoreQuery, SubscribeStore } from 'liwi-subscribe-store';
 import { Query } from 'mingo';
 import { Logger } from 'nightingale-logger';
@@ -35,11 +35,10 @@ class MongoCursor extends AbstractStoreCursor {
     if (!this._result) throw new Error("Cannot call result() before next()");
     return Promise.resolve(this._result);
   }
-  close() {
+  async close() {
     if (this.cursor) {
-      this.cursor.close();
+      await this.cursor.close();
     }
-    return Promise.resolve();
   }
   toArray() {
     return this.cursor.toArray();
@@ -215,6 +214,49 @@ class MongoQuerySingleItem extends AbstractSubscribableStoreQuery {
       });
     });
   }
+  async computeChanges(action, testCriteria) {
+    switch (action.type) {
+      case "inserted": {
+        const filtered = action.next.filter(testCriteria);
+        if (filtered.length === 0) return [];
+        return [{ type: "updated", result: this.transformer(filtered[0]) }];
+      }
+      case "deleted": {
+        const filtered = action.prev.filter(testCriteria);
+        if (filtered.length === 0) return [];
+        return [
+          {
+            type: "deleted",
+            keys: filtered.map((object) => object[this.store.keyPath])
+          }
+        ];
+      }
+      case "updated": {
+        const filtered = action.changes.filter(
+          ([prev, next2]) => testCriteria(prev) || testCriteria(next2)
+        );
+        if (filtered.length === 0) return [];
+        if (this.options.sort) {
+          const { result } = await this.fetch((res) => res);
+          return [{ type: "updated", result }];
+        }
+        if (filtered.length > 1) {
+          throw new Error(
+            "should not match more than 1, use sort if you can have multiple match"
+          );
+        }
+        const [, next] = filtered[0];
+        return [
+          {
+            type: "updated",
+            result: testCriteria(next) ? this.transformer(next) : null
+          }
+        ];
+      }
+      default:
+        throw new Error("Unsupported type");
+    }
+  }
   _subscribe(callback, _includeInitial) {
     const store = super.getSubscribeStore();
     const testCriteria = this.createMingoTestCriteria();
@@ -229,55 +271,12 @@ class MongoQuerySingleItem extends AbstractSubscribableStoreQuery {
       ]);
     }) : Promise.resolve();
     const unsubscribe = store.subscribe(async (action) => {
-      const changes = [];
-      switch (action.type) {
-        case "inserted": {
-          const filtered = action.next.filter(testCriteria);
-          if (filtered.length > 0) {
-            changes.push({
-              type: "updated",
-              result: this.transformer(filtered[0])
-            });
-          }
-          break;
-        }
-        case "deleted": {
-          const filtered = action.prev.filter(testCriteria);
-          if (filtered.length > 0) {
-            changes.push({
-              type: "deleted",
-              keys: filtered.map((object) => object[this.store.keyPath])
-            });
-          }
-          break;
-        }
-        case "updated": {
-          const filtered = action.changes.filter(
-            ([prev, next]) => testCriteria(prev)
-          );
-          if (filtered.length > 0) {
-            if (this.options.sort) {
-              const { result } = await this.fetch((res) => res);
-              changes.push({
-                type: "updated",
-                result
-              });
-            } else if (filtered.length !== 1) {
-              throw new Error(
-                "should not match more than 1, use sort if you can have multiple match"
-              );
-            } else {
-              const [, next] = filtered[0];
-              changes.push({
-                type: "updated",
-                result: testCriteria(next) ? this.transformer(next) : null
-              });
-            }
-          } else if (filtered.length === 0) ;
-          break;
-        }
-        default:
-          throw new Error("Unsupported type");
+      let changes;
+      try {
+        changes = await this.computeChanges(action, testCriteria);
+      } catch (error) {
+        callback(error, []);
+        return;
       }
       if (changes.length === 0) return;
       callback(null, changes);
@@ -709,6 +708,72 @@ const diffIndexes = ({
 };
 const isMongoIndexPlanEmpty = (plan) => plan.toCreate.length === 0 && plan.toRecreate.length === 0 && plan.toCollMod.length === 0 && plan.toDrop.length === 0;
 
+const createReplacePipeline = (replacement) => [
+  {
+    $replaceWith: {
+      $mergeObjects: [
+        { $literal: replacement },
+        {
+          created: { $ifNull: ["$created", { $literal: replacement.created }] }
+        }
+      ]
+    }
+  }
+];
+
+const protectedFields = ["created", "updated"];
+const updatedOverrideOperators = /* @__PURE__ */ new Set([
+  "$set",
+  "$currentDate",
+  "$max"
+]);
+const findProtectedField = (path) => protectedFields.find(
+  (field) => path === field || path.startsWith(`${field}.`)
+);
+const listTouchedPaths = (operator, fields) => {
+  const keys = Object.keys(fields);
+  if (operator !== "$rename") return keys;
+  const renameTargets = Object.values(fields).filter(
+    (target) => typeof target === "string"
+  );
+  return [...keys, ...renameTargets];
+};
+const describeRejection = (field, operator, path) => field === "created" ? `Cannot use ${operator} on "${path}": created is set on insert and never updated` : `Cannot use ${operator} on "${path}": updated can only be set with $set, $currentDate or $max`;
+const validateProtectedFields = (update) => {
+  let isUpdatedSetByCaller = false;
+  const operations = Object.entries(
+    update
+  );
+  for (const [operator, fields] of operations) {
+    if (!fields) continue;
+    for (const path of listTouchedPaths(operator, fields)) {
+      const field = findProtectedField(path);
+      if (!field) continue;
+      if (field === "updated" && path === "updated" && updatedOverrideOperators.has(operator)) {
+        isUpdatedSetByCaller = true;
+        continue;
+      }
+      throw new ProtectedFieldUpdateError(
+        describeRejection(field, operator, path)
+      );
+    }
+  }
+  return { isUpdatedSetByCaller };
+};
+const stampPartialUpdate = (update, now) => {
+  const { isUpdatedSetByCaller } = validateProtectedFields(update);
+  if (isUpdatedSetByCaller || !now) return update;
+  const $set = { ...update.$set, updated: now };
+  return { ...update, $set };
+};
+
+const resolveWriteTime = (options) => options?.touchUpdated === false ? void 0 : /* @__PURE__ */ new Date();
+const toStoredValues = (values) => Object.fromEntries(
+  Object.entries(values).map(([field, value]) => [
+    field,
+    value === void 0 ? null : value
+  ])
+);
 class MongoStore {
   keyPath = "_id";
   connection;
@@ -802,11 +867,37 @@ class MongoStore {
     }
     return object;
   }
+  /**
+   * Always sets `updated` to the write time and keeps the stored `created`: the
+   * object's own `created` and `updated` are ignored. The object is not mutated.
+   */
   async replaceOne(object) {
-    if (!object.updated) object.updated = /* @__PURE__ */ new Date();
     const collection = await this.collection;
-    await collection.replaceOne({ _id: object._id }, object);
-    return object;
+    const next = await collection.findOneAndUpdate(
+      { _id: object._id },
+      createReplacePipeline({ ...object, updated: /* @__PURE__ */ new Date() }),
+      { returnDocument: "after" }
+    );
+    if (!next) {
+      throw new NotFoundError(`Document not found: ${String(object._id)}`);
+    }
+    return next;
+  }
+  /** Same rules as `replaceOne`; `next` is derived from the atomic `prev`, no read back. */
+  async replaceOneWithInfo(object) {
+    const replacement = { ...object, updated: /* @__PURE__ */ new Date() };
+    const collection = await this.collection;
+    const prev = await collection.findOneAndUpdate(
+      { _id: object._id },
+      createReplacePipeline(replacement),
+      { returnDocument: "before" }
+    );
+    if (!prev) return void 0;
+    const storedCreated = prev.created;
+    return {
+      prev,
+      next: { ...replacement, created: storedCreated ?? replacement.created }
+    };
   }
   async upsertOne(object, setOnInsertPartialObject) {
     const result = await this.upsertOneWithInfo(
@@ -816,6 +907,11 @@ class MongoStore {
     return result.object;
   }
   async upsertOneWithInfo(object, setOnInsertPartialObject) {
+    if (setOnInsertPartialObject && "updated" in setOnInsertPartialObject) {
+      throw new ProtectedFieldUpdateError(
+        'Cannot use $setOnInsert on "updated": upsert always sets it with $set, pass it in the object instead'
+      );
+    }
     const $setOnInsert = {
       // @ts-expect-error -- created is Date as set in BaseModel
       created: object.created || /* @__PURE__ */ new Date(),
@@ -840,7 +936,7 @@ class MongoStore {
         object
       };
     }
-    const next = { ...prev, ...$set };
+    const next = { ...prev, ...toStoredValues($set) };
     return {
       resolvedAs: "updated",
       inserted: false,
@@ -851,34 +947,62 @@ class MongoStore {
   replaceSeveral(objects) {
     return Promise.all(objects.map((object) => this.replaceOne(object)));
   }
-  async partialUpdateByKey(key, partialUpdate, criteria) {
+  async partialUpdateByKey(key, partialUpdate, criteria, options) {
+    const update = stampPartialUpdate(partialUpdate, resolveWriteTime(options));
     const collection = await this.collection;
-    const commandResult = await collection.updateOne(
+    const next = await collection.findOneAndUpdate(
       { _id: key, ...criteria },
-      partialUpdate
+      update,
+      { returnDocument: "after" }
+    );
+    if (!next) throw new NotFoundError(`Document not found: ${String(key)}`);
+    return next;
+  }
+  /**
+   * `prev` is read atomically with the write. `next` is read right after it,
+   * so it may already include a later concurrent write, which emits its own change.
+   * Resolves `undefined` when no document matches.
+   */
+  async partialUpdateByKeyWithInfo(key, partialUpdate, criteria, options) {
+    const update = stampPartialUpdate(partialUpdate, resolveWriteTime(options));
+    const collection = await this.collection;
+    const prev = await collection.findOneAndUpdate(
+      { _id: key, ...criteria },
+      update,
+      { returnDocument: "before" }
+    );
+    if (!prev) return void 0;
+    return { prev, next: await this.findByKey(key) };
+  }
+  partialUpdateOne(object, partialUpdate, options) {
+    return this.partialUpdateByKey(
+      object._id,
+      partialUpdate,
+      void 0,
+      options
     );
-    if (!commandResult.acknowledged) {
-      console.error(commandResult);
-      throw new Error("Update failed");
-    }
-    const object = await this.findByKey(key);
-    return object;
   }
-  partialUpdateOne(object, partialUpdate) {
-    return this.partialUpdateByKey(object._id, partialUpdate);
+  /** One `updateMany` command; every document gets the same `updated`. */
+  async partialUpdateMany(criteria, partialUpdate, options) {
+    const update = stampPartialUpdate(partialUpdate, resolveWriteTime(options));
+    const collection = await this.collection;
+    await collection.updateMany(
+      criteria,
+      update
+    );
   }
-  partialUpdateMany(criteria, partialUpdate) {
-    return this.collection.then(
-      (collection) => (
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        collection.updateMany(criteria, partialUpdate)
-      )
-    ).then((res) => void 0);
+  async deleteByKey(key, criteria) {
+    const collection = await this.collection;
+    await collection.deleteOne({ _id: key, ...criteria });
   }
-  deleteByKey(key, criteria) {
-    return this.collection.then(
-      (collection) => collection.deleteOne({ _id: key, ...criteria })
-    ).then(() => void 0);
+  async deleteByKeyWithInfo(key, criteria) {
+    const collection = await this.collection;
+    const prev = await collection.findOneAndDelete({
+      _id: key,
+      ...criteria
+    });
+    if (!prev) return void 0;
+    return { prev };
   }
   deleteOne(object) {
     return this.deleteByKey(object._id);
@@ -933,9 +1057,12 @@ class MongoConnection extends AbstractConnection {
   _connection;
   _connecting;
   connectionFailed;
-  // TODO interface
   constructor(config) {
     super();
+    if ("client" in config) {
+      this.useClient(config.client, "[client]");
+      return;
+    }
     if (!config.database) {
       throw new Error("Missing config database");
     }
@@ -953,31 +1080,7 @@ class MongoConnection extends AbstractConnection {
     logger$1.info("connecting", { connectionStringRedacted });
     const connectPromise = mongodb.MongoClient.connect(connectionString).then((connection) => {
       logger$1.info("connected", { connectionStringRedacted });
-      connection.on("close", () => {
-        logger$1.warn("close", { connectionStringRedacted });
-        this.connectionFailed = true;
-        this.getConnection = () => {
-          throw new Error("MongoDB connection closed");
-        };
-      });
-      connection.on("timeout", () => {
-        logger$1.warn("timeout", { connectionStringRedacted });
-        this.connectionFailed = true;
-        this.getConnection = () => {
-          throw new Error("MongoDB connection timeout");
-        };
-      });
-      connection.on("reconnect", () => {
-        logger$1.warn("reconnect", { connectionStringRedacted });
-        this.connectionFailed = false;
-        this.getConnection = () => Promise.resolve(this._connection);
-      });
-      connection.on("error", (err) => {
-        logger$1.warn("error", { connectionStringRedacted, err });
-      });
-      this._connection = connection;
-      this._connecting = void 0;
-      this.getConnection = () => Promise.resolve(this._connection);
+      this.useClient(connection, connectionStringRedacted);
       return connection;
     }).catch((error) => {
       logger$1.info("not connected", { connectionStringRedacted });
@@ -990,6 +1093,33 @@ class MongoConnection extends AbstractConnection {
     this.getConnection = () => Promise.resolve(connectPromise);
     this._connecting = this.getConnection();
   }
+  useClient(connection, connectionStringRedacted) {
+    connection.on("close", () => {
+      logger$1.warn("close", { connectionStringRedacted });
+      this.connectionFailed = true;
+      this.getConnection = () => {
+        throw new Error("MongoDB connection closed");
+      };
+    });
+    connection.on("timeout", () => {
+      logger$1.warn("timeout", { connectionStringRedacted });
+      this.connectionFailed = true;
+      this.getConnection = () => {
+        throw new Error("MongoDB connection timeout");
+      };
+    });
+    connection.on("reconnect", () => {
+      logger$1.warn("reconnect", { connectionStringRedacted });
+      this.connectionFailed = false;
+      this.getConnection = () => Promise.resolve(this._connection);
+    });
+    connection.on("error", (err) => {
+      logger$1.warn("error", { connectionStringRedacted, err });
+    });
+    this._connection = connection;
+    this._connecting = void 0;
+    this.getConnection = () => Promise.resolve(this._connection);
+  }
   getConnection() {
     throw new Error("call connect()");
   }