@nextage/nx-frame-be 1.0.49 → 1.0.51

package/build/common/base/__test__/base.controller.update-options.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/common/base/__test__/base.controller.update-options.test.js

@@ -0,0 +1,112 @@
+"use strict";
+/* ────────────────────────────────────────────────────────────────────────────
+ * BaseController.update - the options a PARSE can decide
+ *
+ * An update payload cannot say everything about the write it wants. The parse step, which is
+ * where a subclass runs its own derivation, may conclude something the payload has no way to
+ * express - typically that a field must be REMOVED rather than left unwritten. `parseUpdateItem`
+ * can therefore return the options it decided, and `update` carries them to the model together
+ * with the caller's.
+ *
+ * WHAT THESE TESTS GUARD is mostly what does NOT change: an override that returns nothing - every
+ * one that exists today - must reach the model with the caller's own options object, by identity.
+ * A merge that quietly rebuilt that object would be invisible here and would break the callers
+ * that hand the same options around, so identity is asserted and not just deep equality.
+ *
+ * The model is a fake recording its arguments: this is about the controller, and there is nothing
+ * to persist.
+ * ──────────────────────────────────────────────────────────────────────────── */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_controller_1 = require("../base.controller");
+const doc = (over) => (Object.assign(Object.assign({}, over), { toObject: () => (Object.assign({}, over)) }));
+/** Records what `update` hands to the model. */
+const fakeModel = () => ({
+    get: jest.fn((id) => __awaiter(void 0, void 0, void 0, function* () { return doc({ id }); })),
+    update: jest.fn((id, item) => __awaiter(void 0, void 0, void 0, function* () { return doc(Object.assign({ id }, item)); })),
+});
+/** LEGACY: the shape of every override that exists today - declared `Promise<void>`. */
+class LegacyCtrl extends base_controller_1.BaseController {
+    parseUpdateItem(id, item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            item.parsed = true;
+        });
+    }
+}
+/** A parse that decides a removal of its own. */
+class DecidingCtrl extends base_controller_1.BaseController {
+    constructor(model, decided) {
+        super({ model, mergeUpdate: true });
+        this.decided = decided;
+    }
+    parseUpdateItem() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.decided;
+        });
+    }
+}
+/** The options the model was handed, i.e. the fifth argument of `model.update`. */
+const optionsSeenBy = (model) => model.update.mock.calls[0][4];
+describe('BaseController.update - a parse that decides nothing changes nothing', () => {
+    it('hands the CALLER options to the model by identity', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = fakeModel();
+        const ctrl = new LegacyCtrl({ model, mergeUpdate: true });
+        const options = { unsetPaths: ['a'] };
+        yield ctrl.update('id-1', { name: 'N' }, {}, options);
+        expect(optionsSeenBy(model)).toBe(options); // the same object, not a copy
+    }));
+    it('hands over undefined when the caller passed nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = fakeModel();
+        const ctrl = new LegacyCtrl({ model, mergeUpdate: true });
+        yield ctrl.update('id-1', { name: 'N' }, {});
+        expect(optionsSeenBy(model)).toBeUndefined();
+    }));
+    it('still runs the parse: a legacy override keeps mutating the item', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = fakeModel();
+        const ctrl = new LegacyCtrl({ model, mergeUpdate: true });
+        const item = { name: 'N' };
+        yield ctrl.update('id-1', item, {});
+        expect(item.parsed).toBe(true);
+    }));
+});
+describe('BaseController.update - a parse that returns options', () => {
+    it('carries them to the model when the caller asked for nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = fakeModel();
+        const ctrl = new DecidingCtrl(model, { unsetPaths: ['confidentiality'] });
+        yield ctrl.update('id-1', { name: 'N' }, {});
+        expect(optionsSeenBy(model)).toEqual({ unsetPaths: ['confidentiality'] });
+    }));
+    it('unions the paths of the caller and of the parse', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = fakeModel();
+        const ctrl = new DecidingCtrl(model, { unsetPaths: ['confidentiality'] });
+        yield ctrl.update('id-1', { name: 'N' }, {}, { unsetPaths: ['legacyField'] });
+        expect(optionsSeenBy(model).unsetPaths).toEqual(['legacyField', 'confidentiality']);
+    }));
+    it('removes duplicates when both ask for the same path', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = fakeModel();
+        const ctrl = new DecidingCtrl(model, { unsetPaths: ['confidentiality', 'other'] });
+        yield ctrl.update('id-1', { name: 'N' }, {}, { unsetPaths: ['confidentiality'] });
+        expect(optionsSeenBy(model).unsetPaths).toEqual(['confidentiality', 'other']);
+    }));
+    it('leaves the two originals untouched, arrays included', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = fakeModel();
+        const decided = { unsetPaths: ['confidentiality'] };
+        const callerOptions = { unsetPaths: ['legacyField'] };
+        const ctrl = new DecidingCtrl(model, decided);
+        yield ctrl.update('id-1', { name: 'N' }, {}, callerOptions);
+        expect(callerOptions).toEqual({ unsetPaths: ['legacyField'] });
+        expect(decided).toEqual({ unsetPaths: ['confidentiality'] });
+        // and the merged one is a new object, not either of them
+        const seen = optionsSeenBy(model);
+        expect(seen).not.toBe(callerOptions);
+        expect(seen).not.toBe(decided);
+    }));
+});

package/build/common/base/base.controller.d.ts

@@ -48,8 +48,14 @@ export declare abstract class BaseController<TAttrs, TDoc extends BaseMongoDoc,
      * @param id
      * @param item
      * @param context
+     * @returns the options this parse decided for THIS update, or nothing.
+     *
+     * A parse may conclude something that the payload cannot express - typically that a field must
+     * be REMOVED and not merely left unwritten. Returning it here is how that conclusion reaches the
+     * write, without a second call and without borrowing the context, which belongs to the operation
+     * and not to the mutation. Returning nothing is the ordinary case and changes nothing.
      */
-    protected parseUpdateItem(id: string, item: TAttrs, context: NxContext): Promise<void>;
+    protected parseUpdateItem(id: string, item: TAttrs, context: NxContext): Promise<UpdateOptions | void>;
     /**
      *
      * @param item

package/build/common/base/base.controller.js

@@ -10,6 +10,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseController = void 0;
+/**
+ * Merges the options the PARSE decided with the ones the CALLER asked for, leaving both untouched.
+ *
+ * Neither side owns the other: the caller states what it wants removed, the parse states what the
+ * derivation concluded must go, and an update carries the union. `unsetPaths` is unioned without
+ * duplicates - unsetting the same path twice is harmless, but a list that grows on every pass is
+ * noise nobody should have to read.
+ */
+const mergeUpdateOptions = (caller, parsed) => {
+    var _a, _b;
+    const unsetPaths = [...new Set([...((_a = caller === null || caller === void 0 ? void 0 : caller.unsetPaths) !== null && _a !== void 0 ? _a : []), ...((_b = parsed.unsetPaths) !== null && _b !== void 0 ? _b : [])])];
+    return Object.assign(Object.assign(Object.assign({}, caller), parsed), { unsetPaths });
+};
 class BaseController {
     constructor({ model, mergeUpdate }) {
         this.mergeUpdate = false;
@@ -67,6 +80,12 @@ class BaseController {
      * @param id
      * @param item
      * @param context
+     * @returns the options this parse decided for THIS update, or nothing.
+     *
+     * A parse may conclude something that the payload cannot express - typically that a field must
+     * be REMOVED and not merely left unwritten. Returning it here is how that conclusion reaches the
+     * write, without a second call and without borrowing the context, which belongs to the operation
+     * and not to the mutation. Returning nothing is the ordinary case and changes nothing.
      */
     parseUpdateItem(id, item, context) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -114,10 +133,11 @@ class BaseController {
      */
     update(id, item, context, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.parseUpdateItem(id, item, context);
-            // The options belong to THIS update and are handed over untouched: the controller does not
-            // read them and does not interpret them.
-            return this.model.update(id, item, this.mergeUpdate, context, options);
+            const parsed = yield this.parseUpdateItem(id, item, context);
+            // The options belong to THIS update. Those of the caller are handed over untouched - the very
+            // same object when the parse decided nothing, which is the ordinary case; when it did decide
+            // something, the two are merged into a NEW object and neither original is modified.
+            return this.model.update(id, item, this.mergeUpdate, context, parsed ? mergeUpdateOptions(options, parsed) : options);
         });
     }
     /**

package/build/common/base/base.model.d.ts

@@ -85,11 +85,10 @@ export declare class BaseModel<TAttrs, TDoc extends BaseMongoDoc, TMongoModel ex
     aggregateNativeFiltered(pipeline: mongoose.PipelineStage[], params: FilterParams | undefined, context: NxContext): Promise<mongoose.mongo.AggregationCursor<any> | null>;
     /**
      *
-     * @param {*} pipeline
-     * @param {*} params
-     * @param {*} context
+     * @param pipeline
+     * @param options
      */
-    aggregateNative(pipeline: mongoose.PipelineStage[]): mongoose.mongo.AggregationCursor<any>;
+    aggregateNative(pipeline: mongoose.PipelineStage[], options?: mongoose.mongo.AggregateOptions): mongoose.mongo.AggregationCursor<any>;
     /**
      * Simple Find wrapper
      * @param {*} params

package/build/common/base/base.model.js

@@ -175,12 +175,11 @@ class BaseModel extends events_1.EventEmitter {
     }
     /**
      *
-     * @param {*} pipeline
-     * @param {*} params
-     * @param {*} context
+     * @param pipeline
+     * @param options
      */
-    aggregateNative(pipeline) {
-        return this.mgModel.collection.aggregate(pipeline, { allowDiskUse: true });
+    aggregateNative(pipeline, options = {}) {
+        return this.mgModel.collection.aggregate(pipeline, Object.assign({ allowDiskUse: true }, options));
     }
     /**
      * Simple Find wrapper

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextage/nx-frame-be",
-  "version": "1.0.49",
+  "version": "1.0.51",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",