@opra/mongodb 1.30.1 → 1.31.1

package/README.md

@@ -74,5 +74,5 @@ Available under [MIT](LICENSE) license.
 [downloads-url]: https://npmjs.org/package/@opra/mongodb
 [ci-test-image]: https://github.com/panates/opra/actions/workflows/test.yml/badge.svg
 [ci-test-url]: https://github.com/panates/opra/actions/workflows/test.yml
-[coveralls-image]: https://coveralls.io/repos/github/panates/opra/badge.svg?branch=main
+[coveralls-image]: https://coveralls.io/repos/github/panates/opra/badge.svg?branch=dev
 [coveralls-url]: https://coveralls.io/github/panates/opra?branch=main

package/adapter/mongo-patch-generator.js

@@ -1,5 +1,14 @@
-import { ApiField, ComplexType } from '@opra/common';
+import { ApiField, ArrayType, ComplexType } from '@opra/common';
 const FIELD_NAME_PATTERN = /^([-><*:])?(.+)$/;
+/** An array field (`isArray: true`) is declared as `ArrayType(Note)`, not
+ * `Note` directly — its own `.type` is the array wrapper. Every "is this
+ * an array-of-nested-entity field" check below needs the item type, not
+ * the wrapper, however many `[]` layers deep it goes. */
+function unwrapArrayType(type) {
+    while (type instanceof ArrayType)
+        type = type.type;
+    return type;
+}
 /**
  * MongoPatchGenerator is responsible for generating MongoDB update patches from DTO objects.
  * It handles nested objects, array operations ($push, $pull), and field unsetting.
@@ -92,7 +101,8 @@ export class MongoPatchGenerator {
                 result = true;
                 continue;
             }
-            if (field.type instanceof ComplexType) {
+            const itemType = unwrapArrayType(field.type);
+            if (itemType instanceof ComplexType) {
                 if (!value)
                     continue;
                 if (field.isArray) {
@@ -101,7 +111,7 @@ export class MongoPatchGenerator {
                         ctx.initArrayFields.push(pathDot + field.name);
                         if (!value.length)
                             continue;
-                        keyField = field.keyField || field.type.keyField;
+                        keyField = field.keyField || itemType.keyField;
                         if (keyField) {
                             for (let v of value) {
                                 /* Increase arrayIndex and determine a new name for array filter  */
@@ -114,7 +124,7 @@ export class MongoPatchGenerator {
                                 /* Remove key field from object */
                                 delete v[keyField];
                                 /* Process each object in array */
-                                if (this._processComplexType(ctx, field.type, pathDot + field.name + `.$[${arrayFilterName}]`, v, scope)) {
+                                if (this._processComplexType(ctx, itemType, pathDot + field.name + `.$[${arrayFilterName}]`, v, scope)) {
                                     result = true;
                                     /* Add array filter */
                                     ctx.arrayFilters = ctx.arrayFilters || [];
@@ -131,7 +141,7 @@ export class MongoPatchGenerator {
                     if (!(typeof value === 'object'))
                         continue;
                     /* Process nested object */
-                    if (this._processComplexType(ctx, field.type, pathDot + field.name, value, scope)) {
+                    if (this._processComplexType(ctx, itemType, pathDot + field.name, value, scope)) {
                         result = true;
                     }
                     continue;
@@ -157,13 +167,14 @@ export class MongoPatchGenerator {
             if (!(field && field.isArray))
                 continue;
             ctx.$push = ctx.$push || {};
-            if (field.type instanceof ComplexType) {
-                keyField = field.keyField || field.type.keyField;
+            const itemType = unwrapArrayType(field.type);
+            if (itemType instanceof ComplexType) {
+                keyField = field.keyField || itemType.keyField;
                 if (keyField) {
                     if (Array.isArray(value)) {
                         value.forEach(v => {
                             if (!v[keyField]) {
-                                throw new TypeError(`You must provide a key value of ${field.type.name} for $push operation.`);
+                                throw new TypeError(`You must provide a key value of ${itemType.name} for $push operation.`);
                             }
                         });
                         ctx.$push[pathDot + key] = { $each: value };
@@ -171,7 +182,7 @@ export class MongoPatchGenerator {
                     }
                     else {
                         if (!value[keyField]) {
-                            throw new TypeError(`You must provide a key value of ${field.type.name} for $push operation.`);
+                            throw new TypeError(`You must provide a key value of ${itemType.name} for $push operation.`);
                         }
                         ctx.$push[pathDot + key] = value;
                         result = true;
@@ -200,8 +211,9 @@ export class MongoPatchGenerator {
             if (!(field && field.isArray))
                 continue;
             ctx.$pull = ctx.$pull || {};
-            if (field.type instanceof ComplexType) {
-                keyField = field.keyField || field.type.keyField;
+            const itemType = unwrapArrayType(field.type);
+            if (itemType instanceof ComplexType) {
+                keyField = field.keyField || itemType.keyField;
                 if (!keyField)
                     continue;
                 ctx.$pull[pathDot + key] = {

package/adapter/prepare-projection.js

@@ -1,5 +1,13 @@
-import { ApiField, ComplexType, FieldsProjection, parseFieldsProjection, } from '@opra/common';
+import { ApiField, ArrayType, ComplexType, FieldsProjection, parseFieldsProjection, } from '@opra/common';
 import mongodb, {} from 'mongodb';
+/** An array field (`isArray: true`) is declared as `ArrayType(Note)`, not
+ * `Note` directly — its own `.type` is the array wrapper, not the item
+ * type a nested projection needs to recurse into. */
+function unwrapArrayType(type) {
+    while (type instanceof ArrayType)
+        type = type.type;
+    return type;
+}
 /**
  * Prepares the MongoDB projection object based on the data type and requested projection.
  *
@@ -44,10 +52,10 @@ export function prepare(dataType, target, projection, scope) {
             (defaultFields && field.exclusive && !p)) {
             continue;
         }
-        if (field.type instanceof ComplexType &&
-            typeof p?.projection === 'object') {
+        const itemType = unwrapArrayType(field.type);
+        if (itemType instanceof ComplexType && typeof p?.projection === 'object') {
             target[fieldName] = {};
-            prepare(field.type, target[fieldName], p.projection);
+            prepare(itemType, target[fieldName], p.projection);
             continue;
         }
         target[fieldName] = 1;

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@opra/mongodb",
-  "version": "1.30.1",
+  "version": "1.31.1",
   "description": "Opra MongoDB adapter package",
   "author": "Panates",
+  "contributors": [
+    "Eray Hanoglu <e.hanoglu@panates.com>",
+    "Ilker Gurelli <i.gurelli@panates.com>",
+    "Onur Tokel <o.tokel@panates.com>",
+    "Bircan Yuruk <b.yuruk@panates.com>"
+  ],
   "license": "MIT",
   "homepage": "https://www.oprajs.com",
   "dependencies": {
-    "@jsopen/objects": "^2.3.1",
+    "@jsopen/objects": "^2.3.4",
     "tslib": "^2.8.1",
-    "valgen": "^7.0.0"
+    "valgen": "^7.0.3"
   },
   "peerDependencies": {
-    "@opra/common": "^1.30.1",
-    "@opra/core": "^1.30.1",
-    "@opra/http": "^1.30.1",
+    "@opra/common": "^1.31.1",
+    "@opra/core": "^1.31.1",
+    "@opra/http": "^1.31.1",
     "mongodb": "^7.0.0"
   },
   "exports": {
@@ -42,4 +48,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/services/mongo-nested-service.d.ts

@@ -156,7 +156,11 @@ export declare class MongoNestedService<T extends mongodb.Document> extends Mong
     /**
      * Constructs a new instance
      *
-     * @param dataType - The data type of the array elements.
+     * @param dataType - The data type of the *document* that owns the array
+     *   field — not the element type. This service reads `fieldName` off it to
+     *   determine the element type itself (see the `dataType` getter), so
+     *   passing the element type here leaves it looking for the field on the
+     *   wrong type and failing with "Field (...) does not exist".
      * @param fieldName - The name of the field in the document representing the array.
      * @param [options] - The options for the array service.
      * @constructor

package/services/mongo-nested-service.js

@@ -1,5 +1,5 @@
 import { omit } from '@jsopen/objects';
-import { ComplexType, NotAcceptableError, ResourceNotAvailableError, } from '@opra/common';
+import { ArrayType, ComplexType, NotAcceptableError, ResourceNotAvailableError, } from '@opra/common';
 import { ExecutionContext, ServiceBase } from '@opra/core';
 import mongodb from 'mongodb';
 import { isNotNullish } from 'valgen';
@@ -31,7 +31,11 @@ export class MongoNestedService extends MongoService {
     /**
      * Constructs a new instance
      *
-     * @param dataType - The data type of the array elements.
+     * @param dataType - The data type of the *document* that owns the array
+     *   field — not the element type. This service reads `fieldName` off it to
+     *   determine the element type itself (see the `dataType` getter), so
+     *   passing the element type here leaves it looking for the field on the
+     *   wrong type and failing with "Field (...) does not exist".
      * @param fieldName - The name of the field in the document representing the array.
      * @param [options] - The options for the array service.
      * @constructor
@@ -50,7 +54,13 @@ export class MongoNestedService extends MongoService {
      * @throws {@link NotAcceptableError} If the data type is not a ComplexType.
      */
     get dataType() {
-        const t = super.dataType.getField(this.fieldName, this.scope).type;
+        // The field is declared as `ArrayType(Note)` (e.g. `notes: Note[]`) —
+        // its own `.type` is the array wrapper, not the item type directly;
+        // unwrap it (however many `[]` layers deep) before checking, same as
+        // the client-side schema viewer already does for display.
+        let t = super.dataType.getField(this.fieldName, this.scope).type;
+        while (t instanceof ArrayType)
+            t = t.type;
         if (!(t instanceof ComplexType))
             throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
         return t;