@nextage/nx-frame-be 1.0.37 → 1.0.39

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

@@ -289,3 +289,28 @@ it('runs aggregation', () => __awaiter(void 0, void 0, void 0, function* () {
     expect(data.length).toEqual(1);
     expect(data[0].count).toEqual(count);
 }));
+it('bulkWriteVersioned injects version handling on native bulk ops', () => __awaiter(void 0, void 0, void 0, function* () {
+    const code = (0, utils_1.uuid)();
+    // insertOne without an explicit version -> baseline 0 (same as save())
+    yield coded_entity_model_1.ceModel.bulkWriteVersioned([
+        { insertOne: { document: { code, name: 'BWV insert', data: { items: [] } } } }
+    ]);
+    const inserted = yield coded_entity_model_1.ceModel.findOne({ code });
+    expect(inserted.version).toEqual(0);
+    // updateOne without $inc -> auto +1 (native bulk keeps the query-hook guarantee)
+    yield coded_entity_model_1.ceModel.bulkWriteVersioned([
+        { updateOne: { filter: { code }, update: { $set: { name: 'BWV update' } } } }
+    ]);
+    const updated = yield coded_entity_model_1.ceModel.findOne({ code });
+    expect(updated.name).toEqual('BWV update');
+    expect(updated.version).toEqual(1);
+}));
+it('keeps TDoc-specialised subclasses assignable to BaseModel<any, any, any> (regression: TS2322 from bulkWriteVersioned<TDoc>)', () => {
+    // Compile-time guard. `CodedEntity extends BaseModel<..., CodedEntityDoc, ...>` specialises
+    // TDoc; if bulkWriteVersioned is typed on AnyBulkWriteOperation<TDoc> (invariant via
+    // ReplaceOneModel<TDoc>.filter), the subclass method stops being compatible with
+    // BaseModel<any, any, any> and `this` can no longer be passed to a BaseModel<any, any, any>
+    // sink -> this is exactly the auth-srv boot failure (user.model.ts KeyOptions.model).
+    const sink = (m) => m;
+    expect(sink(coded_entity_model_1.ceModel)).toBe(coded_entity_model_1.ceModel);
+});

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

@@ -243,6 +243,33 @@ export declare class BaseModel<TAttrs, TDoc extends BaseMongoDoc, TMongoModel ex
      * @param {*} options
      */
     updateManyNative(filter: FilterParams, update: mongoose.UpdateQuery<TMongoModel>, options?: mongoose.mongo.UpdateOptions): Promise<mongoose.mongo.UpdateResult<Document>>;
+    /**
+     * Execute bulkWrite injecting version handling on each operation, so native bulk
+     * paths keep the same versioning guarantees as the Mongoose query hooks:
+     *  - insertOne             -> set versionKey to 0 when absent (matches save() baseline)
+     *  - updateOne/updateMany  -> add $inc:{version:1} unless the update already touches version
+     *
+     * Upsert ops that do not touch version fall back to $inc (an upsert insert lands at
+     * version 1). Other op kinds (replaceOne, deleteOne, deleteMany) pass through unchanged.
+     *
+     * NB: the parameter is intentionally typed on `AnyBulkWriteOperation<any>` (not `<TDoc>`):
+     * `AnyBulkWriteOperation<TDoc>` is invariant (via `ReplaceOneModel<TDoc>.filter`), so a
+     * `<TDoc>`-typed signature makes each subclass method incompatible with
+     * `BaseModel<any, any, any>` and breaks `this`-assignability (e.g. passing `this` to a
+     * `BaseModel<any, any, any>` sink). Ops are validated/cast internally, so the loose
+     * element type costs nothing.
+     *
+     * @param {*} bulkOps
+     * @param {*} options
+     */
+    bulkWriteVersioned(bulkOps: mongoose.AnyBulkWriteOperation<any>[], options?: mongoose.mongo.BulkWriteOptions): Promise<mongoose.mongo.BulkWriteResult>;
+    /**
+     * Inject the version key into a single bulkWrite operation (see bulkWriteVersioned).
+     *
+     * @param {*} op
+     * @param {*} versionKey
+     */
+    private applyVersionToBulkOp;
     /**
      * Update document using Mongoose wrapper method
      *

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

@@ -19,8 +19,12 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseModel = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
 const events_1 = require("events");
 const utils_1 = require("../utils");
 const constants_1 = require("../constants");
@@ -456,19 +460,35 @@ class BaseModel extends events_1.EventEmitter {
             item = yield this.beforeUpdate(item, context);
             //const res = await this.mgModel.findByIdAndUpdate(id, { $set: item }, { new: true });
             //const itemDoc = this.mgModel.build(Object.assign({ id, item }));
-            const itemDoc = yield this.get(id, context);
-            if (!itemDoc)
-                throw new errors_1.AppError('messages.notFound');
-            // complete merge
-            if (mergeItem) {
-                // item = merge (itemDoc.toObject(), item); // Merge with existing doc
-                item = (0, utils_1.merge)(itemDoc.toObject(), item, (objValue, srcValue) => {
-                    if (Array.isArray(objValue))
-                        return srcValue; // sovrascrivi invece di mergiare
-                });
+            // read-modify-write with optimistic concurrency: on a VersionError (a concurrent
+            // writer bumped the version between get() and save()) re-read the fresh document,
+            // re-apply the update payload and retry a bounded number of times.
+            const maxAttempts = 3;
+            let res;
+            for (let attempt = 1;; attempt++) {
+                const itemDoc = yield this.get(id, context);
+                if (!itemDoc)
+                    throw new errors_1.AppError('messages.notFound');
+                let toApply = item;
+                // complete merge with the freshly read document
+                if (mergeItem) {
+                    // item = merge (itemDoc.toObject(), item); // Merge with existing doc
+                    toApply = (0, utils_1.merge)(itemDoc.toObject(), item, (objValue, srcValue) => {
+                        if (Array.isArray(objValue))
+                            return srcValue; // sovrascrivi invece di mergiare
+                    });
+                }
+                itemDoc.set(toApply);
+                try {
+                    res = yield itemDoc.save();
+                    break;
+                }
+                catch (err) {
+                    if (err instanceof mongoose_1.default.Error.VersionError && attempt < maxAttempts)
+                        continue;
+                    throw err;
+                }
             }
-            itemDoc === null || itemDoc === void 0 ? void 0 : itemDoc.set(item);
-            const res = yield itemDoc.save();
             if (context)
                 context.evtItem = res;
             this.publishCRUDEvent({ type: enums_1.ModelCrudEventType.update, data: { uid: id, model: this.name } }, context);
@@ -506,6 +526,60 @@ class BaseModel extends events_1.EventEmitter {
     updateManyNative(filter, update, options) {
         return this.mgModel.collection.updateMany(filter, update, options);
     }
+    /**
+     * Execute bulkWrite injecting version handling on each operation, so native bulk
+     * paths keep the same versioning guarantees as the Mongoose query hooks:
+     *  - insertOne             -> set versionKey to 0 when absent (matches save() baseline)
+     *  - updateOne/updateMany  -> add $inc:{version:1} unless the update already touches version
+     *
+     * Upsert ops that do not touch version fall back to $inc (an upsert insert lands at
+     * version 1). Other op kinds (replaceOne, deleteOne, deleteMany) pass through unchanged.
+     *
+     * NB: the parameter is intentionally typed on `AnyBulkWriteOperation<any>` (not `<TDoc>`):
+     * `AnyBulkWriteOperation<TDoc>` is invariant (via `ReplaceOneModel<TDoc>.filter`), so a
+     * `<TDoc>`-typed signature makes each subclass method incompatible with
+     * `BaseModel<any, any, any>` and breaks `this`-assignability (e.g. passing `this` to a
+     * `BaseModel<any, any, any>` sink). Ops are validated/cast internally, so the loose
+     * element type costs nothing.
+     *
+     * @param {*} bulkOps
+     * @param {*} options
+     */
+    bulkWriteVersioned(bulkOps, options) {
+        const versionKey = this.mgModel.schema.get('versionKey') || 'version';
+        const versioned = bulkOps.map(op => this.applyVersionToBulkOp(op, versionKey));
+        return this.mgModel.bulkWrite(versioned, options !== null && options !== void 0 ? options : {});
+    }
+    /**
+     * Inject the version key into a single bulkWrite operation (see bulkWriteVersioned).
+     *
+     * @param {*} op
+     * @param {*} versionKey
+     */
+    applyVersionToBulkOp(op, versionKey) {
+        var _a, _b;
+        const anyOp = op;
+        if ((_a = anyOp.insertOne) === null || _a === void 0 ? void 0 : _a.document) {
+            const doc = anyOp.insertOne.document;
+            if (doc[versionKey] === undefined)
+                doc[versionKey] = 0;
+            return op;
+        }
+        const writeOp = (_b = anyOp.updateOne) !== null && _b !== void 0 ? _b : anyOp.updateMany;
+        if (!writeOp)
+            return op;
+        const update = writeOp.update;
+        // update pipelines (arrays) are left untouched
+        if (!update || Array.isArray(update))
+            return op;
+        const nextUpdate = update;
+        const versionOperators = [nextUpdate, nextUpdate.$set, nextUpdate.$unset, nextUpdate.$inc];
+        const touchesVersion = versionOperators.some(operator => !!operator && Object.keys(operator).includes(versionKey));
+        if (touchesVersion)
+            return op;
+        nextUpdate.$inc = nextUpdate.$inc ? Object.assign(Object.assign({}, nextUpdate.$inc), { [versionKey]: 1 }) : { [versionKey]: 1 };
+        return op;
+    }
     /**
      * Update document using Mongoose wrapper method
      *

package/build/common/base/mongo-utils.d.ts

@@ -54,14 +54,16 @@ export declare function loadModel(model: BaseModel<any, any, any>): void;
  * @param { name, modelName, schema, collection, mergeSchema } param
  * @param load
  */
-export declare function createModel<TAttrs, TDoc extends BaseMongoDoc, TMongoModel extends BaseMongoModel<TAttrs, TDoc>, TNxModel>({ name, classDef, modelName, modelParams, collection, schema, mergeSchema }: ModelDef<TDoc, TMongoModel, TNxModel>, load: boolean, logger?: any): TNxModel;
+export declare function createModel<TAttrs, TDoc extends BaseMongoDoc, TMongoModel extends BaseMongoModel<TAttrs, TDoc>, TNxModel>({ name, classDef, modelName, modelParams, collection, schema, mergeSchema, incrementOnSave }: ModelDef<TDoc, TMongoModel, TNxModel>, load: boolean, logger?: any): TNxModel;
 /**
  *
  * @param {*} modelName
  * @param {*} schema
  * @param {*} collection
+ * @param {*} version         enable optimistic concurrency + query version increment
+ * @param {*} incrementOnSave opt-in version bump on save() (Mixed in-place mutations)
  */
-export declare function loadMongoModel<TAttrs extends BaseDBItem, TDoc extends BaseMongoDoc, TMongoModel extends BaseMongoModel<TAttrs, TDoc>>(modelName: string, schema: any, collection: string, version?: boolean): TMongoModel;
+export declare function loadMongoModel<TAttrs extends BaseDBItem, TDoc extends BaseMongoDoc, TMongoModel extends BaseMongoModel<TAttrs, TDoc>>(modelName: string, schema: any, collection: string, version?: boolean, incrementOnSave?: boolean): TMongoModel;
 /**
  * transform string or string array to ObjectId or ObjectId array
  *

package/build/common/base/mongo-utils.js

@@ -58,7 +58,7 @@ function loadModel(model) {
  * @param { name, modelName, schema, collection, mergeSchema } param
  * @param load
  */
-function createModel({ name, classDef, modelName, modelParams, collection, schema, mergeSchema }, load, logger = constants_1.APP.logger) {
+function createModel({ name, classDef, modelName, modelParams, collection, schema, mergeSchema, incrementOnSave }, load, logger = constants_1.APP.logger) {
     let entitySchema;
     if (!name)
         throw new Error('Missing param to create model');
@@ -68,7 +68,7 @@ function createModel({ name, classDef, modelName, modelParams, collection, schem
         entitySchema = exports.codedEntitySchema;
     else
         entitySchema = mergeSchema ? mergeDBSchema(exports.codedEntitySchema, schema) : schema;
-    const mgModel = loadMongoModel(modelName, entitySchema, collection);
+    const mgModel = loadMongoModel(modelName, entitySchema, collection, true, !!incrementOnSave);
     const model = classDef ? new classDef({ name, model: mgModel, params: modelParams, logger }) : new base_model_1.BaseModel({ name, model: mgModel, params: modelParams, logger });
     if (load)
         loadModel(model);
@@ -76,7 +76,7 @@ function createModel({ name, classDef, modelName, modelParams, collection, schem
     //console.log(`created model ${modelName} (load: ${!!load})`);
     return model;
 }
-function enableQueryVersioning(mgSchema, version) {
+function enableQueryVersioning(mgSchema, version, incrementOnSave = false) {
     if (!version)
         return;
     const versionKey = mgSchema.get('versionKey');
@@ -97,6 +97,24 @@ function enableQueryVersioning(mgSchema, version) {
     mgSchema.pre('findOneAndUpdate', addVersionIncrement);
     mgSchema.pre('updateOne', addVersionIncrement);
     mgSchema.pre('updateMany', addVersionIncrement);
+    if (!incrementOnSave)
+        return;
+    // Opt-in (per-model) version bump on save().
+    //
+    // With optimisticConcurrency mongoose already increments the version when a
+    // tracked path is modified. This hook covers the case of Mixed fields mutated
+    // in-place (doc.data.x = y) WITHOUT markModified(): mongoose does not see them
+    // as modified, so no increment would happen and the published event would carry
+    // a stale version. Enable it only on event-source entities that expose Mixed
+    // fields (e.g. companyAsset). increment() shares the same internal version flag
+    // as optimisticConcurrency, so the net effect is at most +1 per save().
+    mgSchema.pre('save', function () {
+        if (this.isNew) // creation: versionKey default acts as v0
+            return;
+        if (this.isModified(versionKey)) // version explicitly set: respect it
+            return;
+        this.increment();
+    });
 }
 ;
 /**
@@ -104,8 +122,10 @@ function enableQueryVersioning(mgSchema, version) {
  * @param {*} modelName
  * @param {*} schema
  * @param {*} collection
+ * @param {*} version         enable optimistic concurrency + query version increment
+ * @param {*} incrementOnSave opt-in version bump on save() (Mixed in-place mutations)
  */
-function loadMongoModel(modelName, schema, collection, version = true) {
+function loadMongoModel(modelName, schema, collection, version = true, incrementOnSave = false) {
     const mgSchema = new mongoose_1.default.Schema(schema, {
         optimisticConcurrency: version,
         versionKey: 'version',
@@ -120,7 +140,7 @@ function loadMongoModel(modelName, schema, collection, version = true) {
     });
     // change documents' version key from __v to version
     mgSchema.set('versionKey', 'version');
-    enableQueryVersioning(mgSchema, version);
+    enableQueryVersioning(mgSchema, version, incrementOnSave);
     mgSchema.statics.build = (attrs) => {
         const item = { _id: attrs.id };
         delete attrs.id;

package/build/common/base/mongo.types.d.ts

@@ -7,6 +7,7 @@ export type ModelDef<TDoc, TMongoModel, TNxModel> = {
     collection: string;
     schema: NxObject;
     mergeSchema?: boolean;
+    incrementOnSave?: boolean;
 };
 export type ModelData<TDoc, TMongoModel> = {
     name: string;

package/package.json

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