liwi-mongo 13.3.3 → 14.0.0

package/src/MongoConnection.ts

@@ -10,8 +10,36 @@ export interface MongoConfig {
   database: string;
   user?: string;
   password?: string;
+  authSource?: string;
 }
 
+interface BuildMongoConnectionStringParams extends MongoConfig {
+  redactCredentials: boolean;
+}
+
+export const buildMongoConnectionString = ({
+  host = "localhost",
+  port = "27017",
+  database,
+  user,
+  password,
+  authSource,
+  redactCredentials,
+}: BuildMongoConnectionStringParams): string =>
+  `mongodb://${
+    user
+      ? `${
+          redactCredentials
+            ? `${user.slice(0, 2)}[redacted]`
+            : encodeURIComponent(user)
+        }:${
+          redactCredentials ? "[redacted]" : encodeURIComponent(password ?? "")
+        }@`
+      : ""
+  }${host}:${port}/${encodeURIComponent(database)}${
+    authSource ? `?authSource=${encodeURIComponent(authSource)}` : ""
+  }`;
+
 export default class MongoConnection extends AbstractConnection {
   _connection?: mongodb.MongoClient;
 
@@ -20,36 +48,21 @@ export default class MongoConnection extends AbstractConnection {
   connectionFailed?: boolean;
 
   // TODO interface
-  constructor({
-    host = "localhost",
-    port = "27017",
-    database,
-    user,
-    password,
-  }: MongoConfig) {
+  constructor(config: MongoConfig) {
     super();
 
-    if (!database) {
+    if (!config.database) {
       throw new Error("Missing config database");
     }
 
-    const buildConnectionString = (redactCredentials: boolean): string =>
-      `mongodb://${
-        user
-          ? `${
-              redactCredentials
-                ? `${user.slice(0, 2)}[redacted]`
-                : encodeURIComponent(user)
-            }:${
-              redactCredentials
-                ? "[redacted]"
-                : encodeURIComponent(password ?? "")
-            }@`
-          : ""
-      }${host}:${port}/${encodeURIComponent(database)}`;
-
-    const connectionString = buildConnectionString(false);
-    const connectionStringRedacted = buildConnectionString(true);
+    const connectionString = buildMongoConnectionString({
+      ...config,
+      redactCredentials: false,
+    });
+    const connectionStringRedacted = buildMongoConnectionString({
+      ...config,
+      redactCredentials: true,
+    });
 
     this.connect(connectionString, connectionStringRedacted);
   }

package/src/MongoCursor.ts

@@ -55,12 +55,10 @@ export default class MongoCursor<
     return Promise.resolve(this._result);
   }
 
-  close(): Promise<void> {
+  async close(): Promise<void> {
     if (this.cursor) {
-      this.cursor.close();
+      await this.cursor.close();
     }
-
-    return Promise.resolve();
   }
 
   toArray(): Promise<Result[]> {

package/src/MongoQueryCollection.test.ts

@@ -1,6 +1,9 @@
 import assert from "node:assert/strict";
 import { beforeEach, describe, it, mock } from "node:test";
+import mongodb from "mongodb";
 import type { MongoBaseModel } from "./MongoBaseModel.ts";
+import MongoConnection from "./MongoConnection.ts";
+import MongoStore from "./MongoStore.ts";
 
 interface TestModel extends MongoBaseModel {
   name: string;
@@ -50,29 +53,12 @@ const collection = {
   countDocuments: () => Promise.resolve(documents.length),
 };
 
-// eslint-disable-next-line n/no-unsupported-features/node-builtins
-mock.module("mongodb", {
-  // @ts-expect-error: not yet typed
-  exports: {
-    default: {
-      MongoClient: {
-        connect: () =>
-          Promise.resolve({
-            on: () => undefined,
-            db: () => ({ collection: () => collection }),
-          }),
-      },
-      ObjectId: class {
-        toString(): string {
-          return "generated-id";
-        }
-      },
-    },
-  },
-});
-
-const { default: MongoConnection } = await import("./MongoConnection.ts");
-const { default: MongoStore } = await import("./MongoStore.ts");
+mock.method(mongodb.MongoClient, "connect", () =>
+  Promise.resolve({
+    on: () => undefined,
+    db: () => ({ collection: () => collection }),
+  } as unknown as mongodb.MongoClient),
+);
 
 const createStore = (): InstanceType<typeof MongoStore<TestModel>> => {
   const connection = new MongoConnection({ database: "test" });

package/src/MongoQueryCollection.ts

@@ -11,7 +11,7 @@ import type {
 } from "liwi-store";
 import type { Actions } from "liwi-subscribe-store";
 import { AbstractSubscribableStoreQuery } from "liwi-subscribe-store";
-import mingo from "mingo";
+import { Query as MingoQuery } from "mingo";
 import type {
   MongoBaseModel,
   MongoInsertType,
@@ -72,7 +72,7 @@ export default class MongoQueryCollection<
         return () => false;
       }
 
-      const mingoQuery = new mingo.Query(this.options.criteria);
+      const mingoQuery = new MingoQuery(this.options.criteria);
       this.testCriteria = mingoQuery.test.bind(mingoQuery);
     }
     return this.testCriteria;

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

@@ -10,7 +10,7 @@ import type {
 } from "liwi-store";
 import type { Actions } from "liwi-subscribe-store";
 import { AbstractSubscribableStoreQuery } from "liwi-subscribe-store";
-import mingo from "mingo";
+import { Query as MingoQuery } from "mingo";
 import type {
   MongoBaseModel,
   MongoInsertType,
@@ -66,7 +66,7 @@ export default class MongoQuerySingleItem<
         return () => true;
       }
 
-      const mingoQuery = new mingo.Query(this.options.criteria);
+      const mingoQuery = new MingoQuery(this.options.criteria);
       this.testCriteria = mingoQuery.test.bind(mingoQuery);
     }
 
@@ -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;