@clairejs/server 3.22.0 → 3.22.2

package/README.md

@@ -1,7 +1,9 @@
 ## Change Log
 
-#### 3.22.0:
+#### 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/common/ServerModelMetadata.d.ts

@@ -2,10 +2,7 @@ import { ModelFieldMetadata, ModelMetadata } from "@clairejs/core";
 import { IPrincipal } from "./auth/IPrincipal";
 import { UriMapperHandler } from "../http/file-upload/types";
 export interface ServerModelFieldMetadata extends ModelFieldMetadata {
-    uriMapper?: {
-        mapper: UriMapperHandler;
-        subkeys: string[];
-    };
+    uriMapper?: UriMapperHandler;
     userResolver?: (principal: IPrincipal) => any;
 }
 export interface ServerModelMetadata extends ModelMetadata {

package/dist/http/decorators.d.ts

@@ -1,4 +1,4 @@
-import { type Constructor, HttpMethod, RecursiveKeys, AbstractModel } from "@clairejs/core";
+import { type Constructor, HttpMethod, Identifiable } from "@clairejs/core";
 import { type UriMapperHandler } from "./file-upload/types";
 import { type HttpResponse } from "./common/HttpResponse";
 import { type IPrincipal } from "../common/auth/IPrincipal";
@@ -21,7 +21,7 @@ export declare const Queries: () => (prototype: AbstractHttpController, property
 export declare const Headers: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
 export declare const Socket: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
 export declare const Raw: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
-export declare const UriMapper: (mapper: UriMapperHandler) => <T extends AbstractModel>(prototype: T, propertyKey: RecursiveKeys<T>) => void;
+export declare const UriMapper: (mapper: UriMapperHandler) => <T extends Identifiable>(prototype: T, propertyKey: keyof T) => void;
 /**
  * Current User decorator only has effect when being used with ICrudRepository.
  *  */

package/dist/http/decorators.js

@@ -61,9 +61,8 @@ export const Headers = () => RequestDeco("headers");
 export const Socket = () => RequestDeco("socket");
 export const Raw = () => RequestDeco("raw");
 export const UriMapper = (mapper) => (prototype, propertyKey) => {
-    const [rootKey, ...keys] = propertyKey.split(".");
-    const field = initFieldMetadata(prototype, rootKey);
-    field.uriMapper = { mapper, subkeys: keys };
+    const field = initFieldMetadata(prototype, propertyKey);
+    field.uriMapper = mapper;
 };
 /**
  * Current User decorator only has effect when being used with ICrudRepository.

package/dist/http/repository/ModelRepository.js

@@ -1,34 +1,14 @@
 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";
 import { LocaleEntry } from "../../system/locale/LocaleEntry";
-const resolveUris = (record, field, subkeys) => {
-    return field.vectorProps
-        ? field.vectorProps.elementDataType === DataType.STRING
-            ? record[field.name]
-            : record[field.name].map((obj) => subkeys.reduce((value, key) => value[key], obj))
-        : [record[field.name]];
+const resolveUris = (record, field) => {
+    return field.vectorProps?.elementDataType === DataType.STRING ? record[field.name] : [record[field.name]];
 };
-const assignUrls = (record, field, subkeys, urls) => {
-    if (field.vectorProps) {
-        if (field.vectorProps.elementDataType === DataType.STRING) {
-            record[field.name] = urls;
-        }
-        else {
-            record[field.name].forEach((obj, index) => {
-                let currentObj = obj;
-                for (let i = 0; i < subkeys.length - 1; i++) {
-                    currentObj = currentObj[subkeys[i]];
-                }
-                currentObj[subkeys[subkeys.length - 1]] = urls[index];
-            });
-        }
-    }
-    else {
-        record[field.name] = urls[0];
-    }
+const assignUrls = (record, field, urls) => {
+    record[field.name] = field.vectorProps?.elementDataType === DataType.STRING ? urls : urls[0];
 };
 export class ModelRepository extends AbstractRepository {
     model;
@@ -157,12 +137,18 @@ export class ModelRepository extends AbstractRepository {
             //-- update record value and not persist yet
             return newUri;
         };
-        if (fileUploadHandler) {
-            for (const field of this.modelMetadata.fields) {
+        const mapRecords = (records, modelMetadata) => {
+            for (const field of modelMetadata.fields) {
                 for (const record of records) {
-                    if (field.uriMapper && record[field.name]) {
-                        const { subkeys, mapper } = field.uriMapper;
-                        const tmpUris = resolveUris(record, field, subkeys);
+                    const value = record[field.name];
+                    if (!value)
+                        continue;
+                    if (field.elementDto) {
+                        mapRecords(field.vectorProps ? value : [value], field.elementDto);
+                    }
+                    else if (field.uriMapper) {
+                        const mapper = field.uriMapper;
+                        const tmpUris = resolveUris(record, field);
                         if (!tmpUris.length) {
                             continue;
                         }
@@ -171,11 +157,14 @@ export class ModelRepository extends AbstractRepository {
                         }
                         operations.push((async () => {
                             const urls = await Promise.all(tmpUris.map((uri, index) => uriHandler(uri, index, mapper, getSystemLocale())));
-                            assignUrls(record, field, subkeys, urls);
+                            assignUrls(record, field, urls);
                         })());
                     }
                 }
             }
+        };
+        if (fileUploadHandler) {
+            mapRecords(records, this.modelMetadata);
         }
         //-- await all operations once to save time
         await Promise.all(operations);
@@ -192,22 +181,30 @@ export class ModelRepository extends AbstractRepository {
             return;
         }
         const mappingOperations = [];
-        for (const record of records) {
-            for (const field of this.modelMetadata.fields) {
-                if (field.uriMapper && record[field.name]) {
-                    const { subkeys } = field.uriMapper;
-                    const uris = resolveUris(record, field, subkeys);
-                    mappingOperations.push((async () => {
-                        const urls = await Promise.all(uris.map(async (uri) => {
-                            return field.mimeProps?.public
-                                ? await fileUploadHandler.resolvePublicUrl(uri)
-                                : await fileUploadHandler.resolvePrivateUrl(uri);
-                        }));
-                        assignUrls(record, field, subkeys, urls);
-                    })());
+        const mapRecords = (records, modelMetadata) => {
+            for (const record of records) {
+                for (const field of modelMetadata.fields) {
+                    const value = record[field.name];
+                    if (!value)
+                        continue;
+                    if (field.elementDto && value) {
+                        mapRecords(field.vectorProps ? value : [value], field.elementDto);
+                    }
+                    else if (field.uriMapper) {
+                        const uris = resolveUris(record, field);
+                        mappingOperations.push((async () => {
+                            const urls = await Promise.all(uris.map(async (uri) => {
+                                return field.mimeProps?.public
+                                    ? await fileUploadHandler.resolvePublicUrl(uri)
+                                    : await fileUploadHandler.resolvePrivateUrl(uri);
+                            }));
+                            assignUrls(record, field, urls);
+                        })());
+                    }
                 }
             }
-        }
+        };
+        mapRecords(records, this.modelMetadata);
         await Promise.all(mappingOperations);
     }
     async createMany({ principal, body, tx, logger, }) {
@@ -284,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
@@ -335,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]);
@@ -364,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
@@ -510,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.0",
+    "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",