@clairejs/server 3.22.1 → 3.22.2

package/README.md

@@ -1,7 +1,8 @@
 ## Change Log
 
-#### 3.22.1:
+#### 3.22.2:
 
+-   fix ModelRepository return correct vector props nested fields
 -   fix uri mapper to map Identifiable classes
 -   remove support of uri mapper for locale fields
 -   support uri mapper for nested array field

package/dist/http/repository/ModelRepository.js

@@ -1,5 +1,5 @@
 import { DataType, getModelById, getServiceProvider, RangeQueryDto, uniqueReducer, leanData, getSystemLocale, Errors, omitData, MODEL_FIELD_SEPARATOR, } from "@clairejs/core";
-import { getDirectFields } from "@clairejs/orm";
+import { getDirectFields, getSafeUpdate, } from "@clairejs/orm";
 import { AbstractFileUploadHandler } from "../file-upload/AbstractFileUploadHandler";
 import { AbstractRepository } from "./AbstractRepository";
 import { LocaleTranslation } from "../../system/locale/LocaleTranslation";
@@ -281,7 +281,11 @@ export class ModelRepository extends AbstractRepository {
             : [];
         await this.beforeReturning(records);
         const projection = this.modelMetadata.fields
-            .filter((field) => !field.multiLocaleColumn && (field.pk || field.serverValue || field.mimeProps))
+            .filter((field) => !field.multiLocaleColumn &&
+            (field.pk ||
+                field.serverValue ||
+                field.mimeProps ||
+                field.vectorProps?.elementDataType === DataType.OBJECT))
             .map((field) => field.name);
         records = this.project(records, projection);
         //-- then create records for has many fields
@@ -332,9 +336,13 @@ export class ModelRepository extends AbstractRepository {
         const allConditions = ops || [];
         const hasManyFields = this.modelMetadata.fields.filter((f) => !!f.hasMany);
         const systemLocale = getSystemLocale();
+        const relevantIdentifiableVectorFields = this.modelMetadata.fields.filter((field) => field.vectorProps?.elementDataType === DataType.OBJECT &&
+            field.elementDto?.fields.some((f) => f.pk) &&
+            body.update[field.name]);
         //-- does not update multi locale columns
         const directUpdateFields = getDirectFields(this.modelMetadata).filter((f) => !f.multiLocaleColumn &&
-            (body.update[f.name] !== undefined || (f.isMultiLocale && !!systemLocale)));
+            (body.update[f.name] !== undefined || (f.isMultiLocale && !!systemLocale)) &&
+            !relevantIdentifiableVectorFields.includes(f));
         const updatedFields = Object.keys(body.update);
         const localeOfFields = this.modelMetadata.fields.filter((f) => updatedFields.includes(f.name) && f.multiLocaleColumn);
         const cleanUp = await this.uriHandling([body.update]);
@@ -361,42 +369,57 @@ export class ModelRepository extends AbstractRepository {
         const nestedQueries = this.getNestedQueries(queries);
         let modified = [];
         let updatedRecords = [];
+        const projections = [
+            ...(queries?.returning || []),
+            ...relevantIdentifiableVectorFields.map((f) => f.name),
+            "id",
+        ];
         if (nestedQueries.length) {
             const tobeUpdated = await this.db
                 .use(this.model, tx)
-                .getMany(condition, { projection: [...(queries?.returning || []), "id"] }, nestedQueries);
-            modified = tobeUpdated.records.map((r) => r.id);
+                .getRecords(condition, { projection: projections }, nestedQueries);
+            modified = tobeUpdated.map((r) => r.id);
             if (modified.length) {
                 if (directUpdateFields.length) {
                     updatedRecords = await this.db
                         .use(this.model, tx)
-                        .updateMany({ _in: { id: modified } }, directUpdate, [
-                        ...(queries?.returning || []),
-                        "id",
-                    ]);
+                        .updateMany({ _in: { id: modified } }, directUpdate, projections);
                 }
                 else {
-                    updatedRecords = tobeUpdated.records;
+                    updatedRecords = tobeUpdated;
                 }
             }
         }
         else {
             if (directUpdateFields.length) {
-                updatedRecords = await this.db
-                    .use(this.model, tx)
-                    .updateMany(condition, directUpdate, [...(queries?.returning || []), "id"]);
+                updatedRecords = await this.db.use(this.model, tx).updateMany(condition, directUpdate, projections);
                 modified = updatedRecords.map((re) => re.id);
             }
             else {
-                const tobeUpdated = await this.db
-                    .use(this.model, tx)
-                    .getMany(condition, { projection: [...(queries?.returning || []), "id"] });
+                const tobeUpdated = await this.db.use(this.model, tx).getMany(condition, { projection: projections });
                 modified = tobeUpdated.records.map((r) => r.id);
                 updatedRecords = tobeUpdated.records;
             }
         }
+        for (const field of relevantIdentifiableVectorFields) {
+            const newValue = body.update[field.name];
+            for (const record of updatedRecords) {
+                const oldValue = record[field.name];
+                const tobeUpdated = newValue.map((newV) => {
+                    const foundOld = oldValue?.find((v) => v.id === newV.id);
+                    return {
+                        ...foundOld,
+                        ...newV,
+                    };
+                });
+                const updatedRecord = await this.db
+                    .use(this.model, tx)
+                    .updateById(record.id, { [field.name]: tobeUpdated }, [field.name]);
+                Object.assign(record, updatedRecord);
+            }
+        }
         //-- body.update here had been modified by uri handling
-        const records = updatedRecords.map((re) => ({ ...re, ...body.update, ...directUpdate }));
+        const records = updatedRecords.map((re) => ({ ...re, ...getSafeUpdate(body.update, this.modelMetadata) }));
         //-- update translations
         if (localeOfFields.length) {
             //-- check if there is missing locale entry for localeFields
@@ -507,19 +530,10 @@ export class ModelRepository extends AbstractRepository {
                 .concat(updatedToBeKept.map((r) => r.modified[0]));
             theRecord[field.name] = (field.hasMany?.single ? finalInnerRecords[0] : finalInnerRecords);
         }
-        let projection = ["id"];
-        if (queries?.returning) {
-            //-- return result
-            projection = [
-                ...projection,
-                ...Object.keys(directUpdate).filter((key) => directUpdate[key] !== undefined),
-                "lastModified",
-            ];
-        }
         //-- ok clean up
         cleanUp().catch((err) => logger?.error("Error in clean up", err));
         await this.beforeReturning(records);
-        return { modified: this.project(records, projection) };
+        return { modified: this.project(records, projections) };
     }
     async getMany({ queries, ops, tx, logger: _logger, }) {
         const conditions = ops || [];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/server",
-    "version": "3.22.1",
+    "version": "3.22.2",
     "description": "Claire server NodeJs framework written in Typescript.",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",
@@ -34,8 +34,8 @@
     },
     "peerDependencies": {
         "@clairejs/client": "^3.4.4",
-        "@clairejs/core": "^3.8.9",
-        "@clairejs/orm": "^3.16.10"
+        "@clairejs/core": "^3.8.10",
+        "@clairejs/orm": "^3.16.15"
     },
     "devDependencies": {
         "@types/cookie-parser": "^1.4.3",