liwi-mongo 13.4.0 → 14.0.0

package/src/MongoQuerySingleItem.test.ts

@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { setImmediate } from "node:timers/promises";
+import type { Changes } from "liwi-store";
+import { SubscribeStore } from "liwi-subscribe-store";
+import type { MongoBaseModel } from "./MongoBaseModel.ts";
+import MongoQuerySingleItem from "./MongoQuerySingleItem.ts";
+import type MongoStore from "./MongoStore.ts";
+
+interface TestModel extends MongoBaseModel {
+  status: string;
+}
+
+const created = new Date("2020-01-01");
+const updated = new Date("2021-01-01");
+
+interface SubscribeSingleItemOptions {
+  cursor?: MongoStore<TestModel>["cursor"];
+  sort?: Record<string, -1 | 1>;
+}
+
+const subscribeSingleItem = ({
+  cursor = () => Promise.reject(new Error("unexpected fetch")),
+  sort,
+}: SubscribeSingleItemOptions = {}): {
+  subscribeStore: SubscribeStore<any, any, TestModel, any, any, any>;
+  received: Changes<string, TestModel | null>[];
+  errors: Error[];
+} => {
+  const store = { keyPath: "_id", cursor } as unknown as MongoStore<TestModel>;
+  const subscribeStore = new SubscribeStore<any, any, TestModel, any, any, any>(
+    store,
+  );
+  const query = new MongoQuerySingleItem<TestModel, never, TestModel | null>(
+    store,
+    { criteria: { status: "open" }, sort },
+  );
+  query.setSubscribeStore(subscribeStore);
+
+  const received: Changes<string, TestModel | null>[] = [];
+  const errors: Error[] = [];
+  query.subscribe((error, changes) => {
+    if (error) errors.push(error);
+    else received.push(changes);
+  });
+  return { subscribeStore, received, errors };
+};
+
+const createCursor = (
+  documents: TestModel[],
+): MongoStore<TestModel>["cursor"] =>
+  (() => {
+    const cursor = {
+      limit: () => Promise.resolve(cursor),
+      toArray: () => Promise.resolve(documents),
+    };
+    return Promise.resolve(cursor);
+  }) as unknown as MongoStore<TestModel>["cursor"];
+
+const draft: TestModel = { _id: "1", status: "draft", created, updated };
+const open: TestModel = { _id: "1", status: "open", created, updated };
+const closed: TestModel = { _id: "1", status: "closed", created, updated };
+const draft2: TestModel = { ...draft, _id: "2" };
+const open2: TestModel = { ...open, _id: "2" };
+
+describe("MongoQuerySingleItem subscription", () => {
+  it("pushes a document that enters the criteria through an update", async () => {
+    const { subscribeStore, received } = subscribeSingleItem();
+
+    subscribeStore.callSubscribed({
+      type: "updated",
+      changes: [[draft, open]],
+    });
+    await setImmediate();
+
+    assert.deepEqual(received, [[{ type: "updated", result: open }]]);
+  });
+
+  it("pushes null when the document leaves the criteria", async () => {
+    const { subscribeStore, received } = subscribeSingleItem();
+
+    subscribeStore.callSubscribed({
+      type: "updated",
+      changes: [[open, closed]],
+    });
+    await setImmediate();
+
+    assert.deepEqual(received, [[{ type: "updated", result: null }]]);
+  });
+
+  it("ignores an update outside the criteria before and after", async () => {
+    const { subscribeStore, received, errors } = subscribeSingleItem();
+
+    subscribeStore.callSubscribed({
+      type: "updated",
+      changes: [[draft, closed]],
+    });
+    await setImmediate();
+
+    assert.deepEqual(received, []);
+    assert.deepEqual(errors, []);
+  });
+
+  it("reports several matches without sort through the callback", async () => {
+    const { subscribeStore, received, errors } = subscribeSingleItem();
+
+    subscribeStore.callSubscribed({
+      type: "updated",
+      changes: [
+        [draft, open],
+        [draft2, open2],
+      ],
+    });
+    await setImmediate();
+
+    assert.deepEqual(received, []);
+    assert.deepEqual(
+      errors.map((error) => error.message),
+      ["should not match more than 1, use sort if you can have multiple match"],
+    );
+  });
+
+  it("refetches with a sort when several documents enter the criteria", async () => {
+    const { subscribeStore, received, errors } = subscribeSingleItem({
+      cursor: createCursor([open2]),
+      sort: { _id: -1 },
+    });
+
+    subscribeStore.callSubscribed({
+      type: "updated",
+      changes: [
+        [draft, open],
+        [draft2, open2],
+      ],
+    });
+    await setImmediate();
+
+    assert.deepEqual(errors, []);
+    assert.deepEqual(received, [[{ type: "updated", result: open2 }]]);
+  });
+
+  it("reports a failed refetch through the callback", async () => {
+    const { subscribeStore, received, errors } = subscribeSingleItem({
+      sort: { _id: -1 },
+    });
+
+    subscribeStore.callSubscribed({
+      type: "updated",
+      changes: [
+        [draft, open],
+        [draft2, open2],
+      ],
+    });
+    await setImmediate();
+
+    assert.deepEqual(received, []);
+    assert.deepEqual(
+      errors.map((error) => error.message),
+      ["unexpected fetch"],
+    );
+  });
+});

package/src/MongoQuerySingleItem.ts

@@ -90,6 +90,56 @@ export default class MongoQuerySingleItem<
     });
   }
 
+  private async computeChanges(
+    action: Actions<Model>,
+    testCriteria: TestCriteria,
+  ): Promise<Changes<KeyValue, Result>> {
+    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, next]) => testCriteria(prev) || testCriteria(next),
+        );
+        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: SubscribeCallback<KeyValue, Result>,
     _includeInitial: boolean,
@@ -111,56 +161,12 @@ export default class MongoQuerySingleItem<
       : Promise.resolve();
 
     const unsubscribe = store.subscribe(async (action: Actions<Model>) => {
-      const changes: Changes<KeyValue, Result> = [];
-      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: Changes<KeyValue, Result>;
+      try {
+        changes = await this.computeChanges(action, testCriteria);
+      } catch (error: unknown) {
+        callback(error as Error, []);
+        return;
       }
 
       if (changes.length === 0) return;

package/src/MongoStore.test.ts

@@ -1,9 +1,11 @@
 import assert from "node:assert/strict";
 import { beforeEach, describe, it, mock } from "node:test";
+import { NotFoundError, ProtectedFieldUpdateError } from "liwi-store";
 import mongodb from "mongodb";
 import type { MongoBaseModel } from "./MongoBaseModel.ts";
 import MongoConnection from "./MongoConnection.ts";
 import MongoStore from "./MongoStore.ts";
+import { createReplacePipeline } from "./writes/createReplacePipeline.ts";
 
 interface TestModel extends MongoBaseModel {
   label: string;
@@ -11,13 +13,26 @@ interface TestModel extends MongoBaseModel {
 }
 
 let findOneAndUpdateCalls: unknown[][];
+let findOneAndDeleteCalls: unknown[][];
+let updateManyCalls: unknown[][];
 let existingDocument: TestModel | null;
+let documentAfterWrite: TestModel | null;
 
 const collection = {
   findOneAndUpdate: (...args: unknown[]) => {
     findOneAndUpdateCalls.push(args);
     return Promise.resolve(existingDocument);
   },
+  findOneAndDelete: (...args: unknown[]) => {
+    findOneAndDeleteCalls.push(args);
+    return Promise.resolve(existingDocument);
+  },
+  findOne: () => Promise.resolve(documentAfterWrite),
+  updateMany: (...args: unknown[]) => {
+    updateManyCalls.push(args);
+    return Promise.resolve({ matchedCount: 1 });
+  },
+  deleteOne: () => Promise.resolve({ deletedCount: existingDocument ? 1 : 0 }),
 };
 
 mock.method(mongodb.MongoClient, "connect", () =>
@@ -97,4 +112,239 @@ describe("MongoStore upsertOneWithInfo", () => {
       prev: existingDocument,
     });
   });
+
+  it("computes next with undefined values as the driver stores them", async () => {
+    existingDocument = {
+      _id: "1",
+      label: "old",
+      status: "x",
+      created,
+      updated,
+    };
+
+    const result = await createStore().upsertOneWithInfo({
+      _id: "1",
+      label: "a",
+      status: undefined,
+      updated,
+    });
+
+    assert.equal(result.object.status, null);
+  });
+
+  it("rejects updated in setOnInsert, which would conflict with $set", async () => {
+    await assert.rejects(
+      createStore().upsertOneWithInfo(
+        { _id: "1", label: "a" },
+        { updated: new Date() },
+      ),
+      ProtectedFieldUpdateError,
+    );
+    assert.deepEqual(findOneAndUpdateCalls, []);
+  });
+});
+
+describe("MongoStore writes with info", () => {
+  const stored: TestModel = { _id: "1", label: "stored", created, updated };
+  const next: TestModel = { _id: "1", label: "next", created, updated };
+  let writeStart: number;
+
+  const assertWriteTime = (value: unknown): Date => {
+    assert.ok(value instanceof Date);
+    assert.ok(value.getTime() >= writeStart && value.getTime() <= Date.now());
+    return value;
+  };
+
+  const stampOf = (update: unknown): unknown =>
+    (update as { $set: { updated: unknown } }).$set.updated;
+
+  const replacementStampOf = (pipeline: unknown): unknown =>
+    (
+      pipeline as [
+        {
+          $replaceWith: {
+            $mergeObjects: [{ $literal: { updated: unknown } }];
+          };
+        },
+      ]
+    )[0].$replaceWith.$mergeObjects[0].$literal.updated;
+
+  beforeEach(() => {
+    writeStart = Date.now();
+    findOneAndUpdateCalls = [];
+    findOneAndDeleteCalls = [];
+    updateManyCalls = [];
+    existingDocument = stored;
+    documentAfterWrite = next;
+  });
+
+  it("partially updates atomically with the criteria and the write time, then reads next", async () => {
+    const result = await createStore().partialUpdateByKeyWithInfo(
+      "1",
+      { $set: { label: "next" } },
+      { status: "open" },
+    );
+
+    const writeTime = assertWriteTime(stampOf(findOneAndUpdateCalls[0]?.[1]));
+    assert.deepEqual(findOneAndUpdateCalls, [
+      [
+        { _id: "1", status: "open" },
+        { $set: { label: "next", updated: writeTime } },
+        { returnDocument: "before" },
+      ],
+    ]);
+    assert.deepEqual(result, { prev: stored, next });
+  });
+
+  it("does not stamp updated with touchUpdated: false", async () => {
+    await createStore().partialUpdateByKey(
+      "1",
+      { $set: { label: "next" } },
+      undefined,
+      { touchUpdated: false },
+    );
+
+    assert.deepEqual(findOneAndUpdateCalls, [
+      [{ _id: "1" }, { $set: { label: "next" } }, { returnDocument: "after" }],
+    ]);
+  });
+
+  it("rejects a protected field update before writing", async () => {
+    await assert.rejects(
+      createStore().partialUpdateByKey("1", { $set: { created: new Date() } }),
+      ProtectedFieldUpdateError,
+    );
+    assert.deepEqual(findOneAndUpdateCalls, []);
+  });
+
+  it("partially updates many documents in one command with one write time", async () => {
+    await createStore().partialUpdateMany(
+      { status: "open" },
+      { $set: { label: "next" } },
+    );
+
+    const writeTime = assertWriteTime(stampOf(updateManyCalls[0]?.[1]));
+    assert.deepEqual(updateManyCalls, [
+      [{ status: "open" }, { $set: { label: "next", updated: writeTime } }],
+    ]);
+  });
+
+  it("resolves next undefined when the document is deleted before the read-back", async () => {
+    documentAfterWrite = null;
+
+    const result = await createStore().partialUpdateByKeyWithInfo("1", {
+      $set: { label: "next" },
+    });
+
+    assert.deepEqual(result, { prev: stored, next: undefined });
+  });
+
+  it("resolves undefined when the partial update matches nothing", async () => {
+    existingDocument = null;
+
+    const store = createStore();
+
+    assert.equal(
+      await store.partialUpdateByKeyWithInfo("1", { $set: { label: "x" } }),
+      undefined,
+    );
+    await assert.rejects(
+      store.partialUpdateByKey("1", { $set: { label: "x" } }),
+      NotFoundError,
+    );
+  });
+
+  it("replaces atomically, keeping the stored created and stamping updated", async () => {
+    const callerCreated = new Date("2025-01-01");
+    const object: TestModel = {
+      _id: "1",
+      label: "next",
+      created: callerCreated,
+      updated,
+    };
+
+    const result = await createStore().replaceOneWithInfo(object);
+
+    const writeTime = assertWriteTime(
+      replacementStampOf(findOneAndUpdateCalls[0]?.[1]),
+    );
+    const replacement = { ...object, updated: writeTime };
+    assert.deepEqual(findOneAndUpdateCalls, [
+      [
+        { _id: "1" },
+        createReplacePipeline(replacement),
+        { returnDocument: "before" },
+      ],
+    ]);
+    assert.deepEqual(result, {
+      prev: stored,
+      next: { ...replacement, created },
+    });
+    assert.equal(object.updated, updated);
+  });
+
+  it("partially updates in one call returning the document after the write", async () => {
+    existingDocument = next;
+
+    const result = await createStore().partialUpdateByKey("1", {
+      $set: { label: "next" },
+    });
+
+    const writeTime = assertWriteTime(stampOf(findOneAndUpdateCalls[0]?.[1]));
+    assert.deepEqual(findOneAndUpdateCalls, [
+      [
+        { _id: "1" },
+        { $set: { label: "next", updated: writeTime } },
+        { returnDocument: "after" },
+      ],
+    ]);
+    assert.deepEqual(result, next);
+  });
+
+  it("replaceOne returns the stored document and leaves the caller's object untouched", async () => {
+    existingDocument = next;
+    const object: TestModel = { _id: "1", label: "next", created, updated };
+
+    const result = await createStore().replaceOne(object);
+
+    const writeTime = assertWriteTime(
+      replacementStampOf(findOneAndUpdateCalls[0]?.[1]),
+    );
+    assert.deepEqual(findOneAndUpdateCalls, [
+      [
+        { _id: "1" },
+        createReplacePipeline({ ...object, updated: writeTime }),
+        { returnDocument: "after" },
+      ],
+    ]);
+    assert.equal(result, next);
+    assert.equal(object.updated, updated);
+  });
+
+  it("throws NotFoundError when replacing a missing document", async () => {
+    existingDocument = null;
+
+    await assert.rejects(
+      createStore().replaceOne({ _id: "1", label: "x", created, updated }),
+      NotFoundError,
+    );
+  });
+
+  it("deletes atomically with the criteria and returns prev", async () => {
+    const result = await createStore().deleteByKeyWithInfo("1", {
+      status: "open",
+    });
+
+    assert.deepEqual(findOneAndDeleteCalls, [[{ _id: "1", status: "open" }]]);
+    assert.deepEqual(result, { prev: stored });
+  });
+
+  it("resolves when deleting a missing document", async () => {
+    existingDocument = null;
+
+    const store = createStore();
+
+    assert.equal(await store.deleteByKeyWithInfo("1"), undefined);
+    await store.deleteByKey("1");
+  });
 });