liwi-mongo 12.0.0 → 13.1.0

package/package.json

@@ -1,67 +1,72 @@
 {
   "name": "liwi-mongo",
-  "version": "12.0.0",
+  "version": "13.1.0",
   "description": "mongo implementation for liwi",
   "keywords": [],
-  "author": "Christophe Hurpeau <christophe@hurpeau.com> (https://christophe.hurpeau.com)",
+  "homepage": "https://github.com/christophehurpeau/liwi",
+  "bugs": {
+    "url": "https://github.com/christophehurpeau/liwi/issues"
+  },
   "license": "ISC",
+  "author": "Christophe Hurpeau <christophe@hurpeau.com> (https://christophe.hurpeau.com)",
   "repository": {
     "type": "git",
-    "url": "https://github.com/liwijs/liwi.git",
+    "url": "https://github.com/christophehurpeau/liwi.git",
     "directory": "packages/liwi-mongo"
   },
-  "homepage": "https://github.com/liwijs/liwi",
+  "files": [
+    "src",
+    "dist"
+  ],
   "type": "module",
-  "engines": {
-    "node": ">=18.12.0"
-  },
   "sideEffects": false,
-  "main": "./dist/index-node18.mjs",
+  "main": "./dist/index-node.mjs",
   "types": "./dist/definitions/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/definitions/index.d.ts",
       "node": {
-        "import": "./dist/index-node18.mjs"
+        "import": "./dist/index-node.mjs"
       }
     }
   },
-  "files": [
-    "src",
-    "dist"
-  ],
-  "scripts": {
-    "build": "yarn clean:build && rollup --config rollup.config.mjs && yarn run build:definitions",
-    "build:definitions": "tsc -p tsconfig.json",
-    "clean": "yarn clean:build",
-    "clean:build": "pob-babel-clean-out dist",
-    "lint": "yarn run lint:eslint",
-    "lint:eslint": "yarn ../.. run eslint --report-unused-disable-directives --resolve-plugins-relative-to . --quiet packages/liwi-mongo",
-    "watch": "yarn clean:build && rollup --config rollup.config.mjs --watch"
+  "dependencies": {
+    "mingo": "~6.2.7",
+    "mongodb": "^7.4.0",
+    "nightingale-logger": "^18.2.0",
+    "liwi-store": "13.1.0",
+    "liwi-subscribe-store": "13.1.0"
+  },
+  "devDependencies": {
+    "@pob/rollup-esbuild": "9.1.1",
+    "typescript": "6.0.3"
+  },
+  "engines": {
+    "node": ">=22.18.0"
   },
   "pob": {
-    "babelEnvs": [
+    "bundler": "rollup-esbuild",
+    "entries": [
+      "index"
+    ],
+    "envs": [
       {
         "target": "node",
-        "version": "18"
+        "version": "22",
+        "omitVersionInFileName": true
       }
     ],
-    "entries": [
-      "index"
-    ]
-  },
-  "prettier": "@pob/root/prettier-config",
-  "dependencies": {
-    "liwi-store": "12.0.0",
-    "liwi-subscribe-store": "12.0.0",
-    "mingo": "^6.2.7",
-    "mongodb": "^6.0.0",
-    "nightingale-logger": "^15.0.0"
+    "typescript": true
   },
-  "devDependencies": {
-    "@babel/core": "7.24.3",
-    "pob-babel": "38.0.3",
-    "typescript": "5.3.3"
+  "scripts": {
+    "build": "pnpm run clean:build && rollup --config rollup.config.mjs && pnpm run build:definitions",
+    "build:definitions": "tsc -p tsconfig.json",
+    "clean": "yarn clean:build",
+    "clean:build": "pob-esbuild-clean-out dist",
+    "lint": "pnpm run lint:eslint",
+    "lint:eslint": "pnpm run --dir '../..' eslint --quiet 'packages/liwi-mongo'",
+    "tsc": "tsc",
+    "watch": "yarn clean:build && rollup --config rollup.config.mjs --watch"
   }
 }

package/src/MongoBaseModel.ts

@@ -1,9 +1,10 @@
-import type { BaseModel, AllowedKeyValue, InsertType } from 'liwi-store';
+import type { AllowedKeyValue, BaseModel, InsertType } from "liwi-store";
 
-export type MongoKeyPath = '_id';
+export type MongoKeyPath = "_id";
 
-export interface MongoBaseModel<KeyValue extends AllowedKeyValue = string>
-  extends BaseModel {
+export interface MongoBaseModel<
+  KeyValue extends AllowedKeyValue = string,
+> extends BaseModel {
   _id: KeyValue;
 }
 

package/src/MongoConnection.ts

@@ -1,8 +1,16 @@
-import { AbstractConnection } from 'liwi-store';
-import mongodb from 'mongodb';
-import { Logger } from 'nightingale-logger';
-
-const logger = new Logger('liwi:mongo:MongoConnection');
+import { AbstractConnection } from "liwi-store";
+import mongodb from "mongodb";
+import { Logger } from "nightingale-logger";
+
+const logger = new Logger("liwi:mongo:MongoConnection");
+
+export interface MongoConfig {
+  host?: string;
+  port?: number | string;
+  database: string;
+  user?: string;
+  password?: string;
+}
 
 export default class MongoConnection extends AbstractConnection {
   _connection?: mongodb.MongoClient;
@@ -12,36 +20,33 @@ export default class MongoConnection extends AbstractConnection {
   connectionFailed?: boolean;
 
   // TODO interface
-  constructor(config: Map<string, number | string>) {
+  constructor({
+    host = "localhost",
+    port = "27017",
+    database,
+    user,
+    password,
+  }: MongoConfig) {
     super();
 
-    if (!config.has('host')) {
-      config.set('host', 'localhost');
-    }
-    if (!config.has('port')) {
-      config.set('port', '27017');
-    }
-    if (!config.has('database')) {
-      throw new Error('Missing config database');
+    if (!database) {
+      throw new Error("Missing config database");
     }
 
     const buildConnectionString = (redactCredentials: boolean): string =>
       `mongodb://${
-        config.has('user')
+        user
           ? `${
               redactCredentials
-                ? `${(config.get('user') as string).slice(0, 2)}[redacted]`
-                : (config.get('user') as string)
+                ? `${user.slice(0, 2)}[redacted]`
+                : encodeURIComponent(user)
             }:${
               redactCredentials
-                ? '[redacted]'
-                : (config.get('password') as string)
+                ? "[redacted]"
+                : encodeURIComponent(password ?? "")
             }@`
-          : ''
-      }` +
-      `${config.get('host') as string}:${config.get('port') as string}/${
-        config.get('database') as string
-      }`;
+          : ""
+      }${host}:${port}/${encodeURIComponent(database)}`;
 
     const connectionString = buildConnectionString(false);
     const connectionStringRedacted = buildConnectionString(true);
@@ -50,32 +55,32 @@ export default class MongoConnection extends AbstractConnection {
   }
 
   connect(connectionString: string, connectionStringRedacted: string): void {
-    logger.info('connecting', { connectionStringRedacted });
+    logger.info("connecting", { connectionStringRedacted });
 
     const connectPromise = mongodb.MongoClient.connect(connectionString)
       .then((connection) => {
-        logger.info('connected', { connectionStringRedacted });
-        connection.on('close', () => {
-          logger.warn('close', { connectionStringRedacted });
+        logger.info("connected", { connectionStringRedacted });
+        connection.on("close", () => {
+          logger.warn("close", { connectionStringRedacted });
           this.connectionFailed = true;
           this.getConnection = () => {
-            throw new Error('MongoDB connection closed');
+            throw new Error("MongoDB connection closed");
           };
         });
-        connection.on('timeout', () => {
-          logger.warn('timeout', { connectionStringRedacted });
+        connection.on("timeout", () => {
+          logger.warn("timeout", { connectionStringRedacted });
           this.connectionFailed = true;
           this.getConnection = () => {
-            throw new Error('MongoDB connection timeout');
+            throw new Error("MongoDB connection timeout");
           };
         });
-        connection.on('reconnect', () => {
-          logger.warn('reconnect', { connectionStringRedacted });
+        connection.on("reconnect", () => {
+          logger.warn("reconnect", { connectionStringRedacted });
           this.connectionFailed = false;
           this.getConnection = () => Promise.resolve(this._connection!);
         });
-        connection.on('error', (err) => {
-          logger.warn('error', { connectionStringRedacted, err });
+        connection.on("error", (err) => {
+          logger.warn("error", { connectionStringRedacted, err });
         });
 
         this._connection = connection;
@@ -83,12 +88,12 @@ export default class MongoConnection extends AbstractConnection {
         this.getConnection = () => Promise.resolve(this._connection!);
         return connection;
       })
-      .catch((error) => {
-        logger.info('not connected', { connectionStringRedacted });
-        console.error(error.message || error);
+      .catch((error: unknown) => {
+        logger.info("not connected", { connectionStringRedacted });
+        console.error((error as Error).message || error);
         // throw err;
         process.nextTick(() => {
-          // eslint-disable-next-line unicorn/no-process-exit, n/no-process-exit
+          // eslint-disable-next-line unicorn/no-process-exit
           process.exit(1);
         });
 
@@ -99,13 +104,12 @@ export default class MongoConnection extends AbstractConnection {
     this._connecting = this.getConnection();
   }
 
-  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   getConnection(): Promise<mongodb.MongoClient> {
-    throw new Error('call connect()');
+    throw new Error("call connect()");
   }
 
   async close(): Promise<void> {
-    this.getConnection = () => Promise.reject(new Error('Connection closed'));
+    this.getConnection = () => Promise.reject(new Error("Connection closed"));
     if (this._connection) {
       await this._connection.close();
       this._connection = undefined;

package/src/MongoCursor.ts

@@ -1,13 +1,13 @@
-import { AbstractStoreCursor } from 'liwi-store';
-import type { AllowedKeyValue } from 'liwi-store';
-import type { FindCursor } from 'mongodb';
-import type { MongoBaseModel } from './MongoBaseModel';
-import type MongoStore from './MongoStore';
+import { AbstractStoreCursor } from "liwi-store";
+import type { AllowedKeyValue } from "liwi-store";
+import type { FindCursor } from "mongodb";
+import type { MongoBaseModel } from "./MongoBaseModel";
+import type MongoStore from "./MongoStore";
 
 export default class MongoCursor<
   Model extends MongoBaseModel<KeyValue>,
   Result extends Partial<Model> = Model,
-  KeyValue extends AllowedKeyValue = Model['_id'],
+  KeyValue extends AllowedKeyValue = Model["_id"],
 > extends AbstractStoreCursor<
   MongoStore<Model, KeyValue>,
   KeyValue,
@@ -51,7 +51,7 @@ export default class MongoCursor<
   }
 
   override result(): Promise<Result> {
-    if (!this._result) throw new Error('Cannot call result() before next()');
+    if (!this._result) throw new Error("Cannot call result() before next()");
     return Promise.resolve(this._result);
   }
 

package/src/MongoQueryCollection.test.ts

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import { beforeEach, describe, it, mock } from "node:test";
+import type { MongoBaseModel } from "./MongoBaseModel.ts";
+
+interface TestModel extends MongoBaseModel {
+  name: string;
+  age: number;
+}
+
+interface FakeCursor {
+  sortArg?: unknown;
+  projectArg?: unknown;
+  skipArg?: number;
+  limitArg?: number;
+  sort: (arg: unknown) => FakeCursor;
+  project: (arg: unknown) => FakeCursor;
+  skip: (arg: number) => FakeCursor;
+  limit: (arg: number) => FakeCursor;
+  toArray: () => Promise<TestModel[]>;
+}
+
+const documents: TestModel[] = [
+  { _id: "1", name: "a", age: 1, created: new Date(), updated: new Date() },
+];
+
+let cursor: FakeCursor;
+
+const createCursor = (): FakeCursor => ({
+  sort(arg) {
+    this.sortArg = arg;
+    return this;
+  },
+  project(arg) {
+    this.projectArg = arg;
+    return this;
+  },
+  skip(arg) {
+    this.skipArg = arg;
+    return this;
+  },
+  limit(arg) {
+    this.limitArg = arg;
+    return this;
+  },
+  toArray: () => Promise.resolve(documents),
+});
+
+const collection = {
+  find: () => cursor,
+  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");
+
+const createStore = (): InstanceType<typeof MongoStore<TestModel>> => {
+  const connection = new MongoConnection({ database: "test" });
+  return new MongoStore<TestModel>(connection, "test");
+};
+
+describe("MongoQueryCollection fields", () => {
+  beforeEach(() => {
+    cursor = createCursor();
+  });
+
+  it("applies the projection from options.fields", async () => {
+    const query = createStore().createQueryCollection({
+      criteria: { age: { $gt: 0 } },
+      fields: { name: 1 },
+      transformer: ({ _id, name }) => ({ _id, name }),
+    });
+
+    await query.fetch((result) => result);
+
+    assert.deepEqual(cursor.projectArg, { name: 1 });
+  });
+
+  it("does not call project when options.fields is omitted", async () => {
+    const query = createStore().createQueryCollection({
+      criteria: { age: { $gt: 0 } },
+    });
+
+    await query.fetch((result) => result);
+
+    assert.equal(cursor.projectArg, undefined);
+  });
+});

package/src/MongoQueryCollection.ts

@@ -1,24 +1,24 @@
-/* eslint-disable complexity, max-lines */
+/* eslint-disable complexity */
 import type {
-  QuerySubscription,
-  SubscribeCallback,
-  QueryResult,
-  QueryParams,
+  AllowedKeyValue,
   Changes,
   QueryOptions,
+  QueryParams,
+  QueryResult,
+  QuerySubscription,
+  SubscribeCallback,
   Transformer,
-  AllowedKeyValue,
-} from 'liwi-store';
-import type { Actions } from 'liwi-subscribe-store';
-import { AbstractSubscribableStoreQuery } from 'liwi-subscribe-store';
-import mingo from 'mingo';
+} from "liwi-store";
+import type { Actions } from "liwi-subscribe-store";
+import { AbstractSubscribableStoreQuery } from "liwi-subscribe-store";
+import mingo from "mingo";
 import type {
   MongoBaseModel,
   MongoInsertType,
   MongoKeyPath,
-} from './MongoBaseModel';
-import type MongoCursor from './MongoCursor';
-import type MongoStore from './MongoStore';
+} from "./MongoBaseModel";
+import type MongoCursor from "./MongoCursor";
+import type MongoStore from "./MongoStore";
 
 const identityTransformer = <
   Model extends MongoBaseModel<any>,
@@ -32,7 +32,7 @@ type TestCriteria = (obj: any) => boolean;
 export default class MongoQueryCollection<
   Model extends MongoBaseModel<KeyValue>,
   Params extends QueryParams<Params> = never,
-  KeyValue extends AllowedKeyValue = Model['_id'],
+  KeyValue extends AllowedKeyValue = Model["_id"],
   Item extends Record<MongoKeyPath, KeyValue> = Model,
 > extends AbstractSubscribableStoreQuery<
   MongoKeyPath,
@@ -68,7 +68,7 @@ export default class MongoQueryCollection<
       }
 
       // criteria not supported by mingo: updates will not work
-      if ('$text' in this.options.criteria) {
+      if ("$text" in this.options.criteria) {
         return () => false;
       }
 
@@ -106,7 +106,7 @@ export default class MongoQueryCollection<
       ? this.fetch(({ result, meta, info }: QueryResult<Item[]>) => {
           callback(null, [
             {
-              type: 'initial',
+              type: "initial",
               initial: result,
               queryInfo: info,
               meta,
@@ -118,27 +118,27 @@ export default class MongoQueryCollection<
     const unsubscribe = store.subscribe((action: Actions<Model>) => {
       const changes: Changes<KeyValue, Item[]> = [];
       switch (action.type) {
-        case 'inserted': {
+        case "inserted": {
           const filtered = action.next.filter(testCriteria);
           if (filtered.length > 0) {
             changes.push({
-              type: 'inserted',
+              type: "inserted",
               result: filtered.map(this.transformer),
             });
           }
           break;
         }
-        case 'deleted': {
+        case "deleted": {
           const filtered = action.prev.filter(testCriteria);
           if (filtered.length > 0) {
             changes.push({
-              type: 'deleted',
+              type: "deleted",
               keys: filtered.map((object) => object[this.store.keyPath]),
             });
           }
           break;
         }
-        case 'updated': {
+        case "updated": {
           const {
             deleted,
             updated,
@@ -162,19 +162,19 @@ export default class MongoQueryCollection<
           });
 
           if (deleted.length > 0) {
-            changes.push({ type: 'deleted', keys: deleted });
+            changes.push({ type: "deleted", keys: deleted });
           }
           if (updated.length > 0) {
-            changes.push({ type: 'updated', result: updated });
+            changes.push({ type: "updated", result: updated });
           }
           if (inserted.length > 0) {
-            changes.push({ type: 'inserted', result: inserted });
+            changes.push({ type: "inserted", result: inserted });
           }
 
           break;
         }
         default:
-          throw new Error('Unsupported type');
+          throw new Error("Unsupported type");
       }
 
       if (changes.length === 0) return;
@@ -217,6 +217,7 @@ export default class MongoQueryCollection<
     const cursor = await this.store.cursor(
       this.options.criteria,
       this.options.sort,
+      this.options.fields,
     );
 
     if (this.options.skip) {