@clairejs/server 3.19.7 → 3.20.1

package/README.md

@@ -1,5 +1,11 @@
 ## Change Log
 
+#### 3.20.1:
+
+-   fix req not resolve leads to undefined request in DefaultHttpRequestHandler
+-   fix concurrent transactions in updateRecords
+-   update claire core, claire orm and fix returning
+
 #### 3.19.7:
 
 -   public expose endpointMetadat in HttpRequest

package/dist/http/controller/CrudHttpController.js

@@ -182,12 +182,16 @@ export class CrudHttpController extends AbstractHttpController {
         const principal = authProvider && (await authProvider.resolvePrincipal(req));
         const body = req.getBody();
         const queries = req.getQuery();
-        const updatedRecords = await Promise.all(body.records.map((record) => this.crudRepository.updateMany({
-            principal,
-            queries: { ...queries, fields: { id: [record.id] } },
-            body: { update: omitData(record, ["id"]) },
-            tx,
-        })));
+        const updatedRecords = [];
+        for (const record of body.records) {
+            const result = await this.crudRepository.updateMany({
+                principal,
+                queries: { ...queries, fields: { id: [record.id] } },
+                body: { update: omitData(record, ["id"]) },
+                tx,
+            });
+            updatedRecords.push(result);
+        }
         const response = {
             modified: updatedRecords.map((re) => re.modified[0]),
         };

package/dist/http/controller/DefaultHttpRequestHandler.js

@@ -31,20 +31,22 @@ let DefaultHttpRequestHandler = class DefaultHttpRequestHandler extends Abstract
     }
     async handleRequest(endpoint, req) {
         //-- supply correct order of params into handler
-        const params = Object.values(endpoint.params || {}).map((p) => {
-            switch (p.source) {
-                case "body":
-                    return req.getBody();
-                case "params":
-                    return req.getParams();
-                case "queries":
-                    return req.getQuery();
-                case "headers":
-                    return req.headers;
-                case "raw":
-                    return req;
-            }
-        });
+        const params = !endpoint.params
+            ? [req]
+            : Object.values(endpoint.params).map((p) => {
+                switch (p.source) {
+                    case "body":
+                        return req.getBody();
+                    case "params":
+                        return req.getParams();
+                    case "queries":
+                        return req.getQuery();
+                    case "headers":
+                        return req.headers;
+                    case "raw":
+                        return req;
+                }
+            });
         const response = await endpoint.controller[endpoint.name](...params);
         //-- validate response value against response dto
         if (endpoint.responseDto) {

package/dist/http/repository/DtoRepository.js

@@ -201,7 +201,6 @@ export class DtoRepository extends AbstractRepository {
         const result = { id: queries.fields.id[0] };
         await this.getMapValue(result, async () => [], this.dissolver(result), undefined, async (mapper) => {
             const repo = new ModelRepository(mapper.modelClass, this.db);
-            //const nestedQueries = mapper.forwardQuery();
             const nestedOps = mapper.forwardOps(ops);
             const result = await repo.deleteMany({
                 queries: { returning: queries?.returning },

package/dist/http/repository/ModelRepository.js

@@ -395,32 +395,39 @@ export class ModelRepository extends AbstractRepository {
         if (nestedQueries.length) {
             const tobeUpdated = await this.db
                 .use(this.model, tx)
-                .getMany(condition, { projection: ["id"] }, nestedQueries);
+                .getMany(condition, { projection: [...(queries?.returning || []), "id"] }, nestedQueries);
             modified = tobeUpdated.records.map((r) => r.id);
             if (modified.length) {
                 if (directUpdateFields.length) {
                     updatedRecords = await this.db
                         .use(this.model, tx)
-                        .updateMany({ _in: { id: modified } }, directUpdate, true);
+                        .updateMany({ _in: { id: modified } }, directUpdate, [
+                        ...(queries?.returning || []),
+                        "id",
+                    ]);
                 }
                 else {
-                    updatedRecords = modified.map((id) => ({ id }));
+                    updatedRecords = tobeUpdated.records;
                 }
             }
         }
         else {
             if (directUpdateFields.length) {
-                updatedRecords = await this.db.use(this.model, tx).updateMany(condition, directUpdate, true);
+                updatedRecords = await this.db
+                    .use(this.model, tx)
+                    .updateMany(condition, directUpdate, [...(queries?.returning || []), "id"]);
                 modified = updatedRecords.map((re) => re.id);
             }
             else {
-                const tobeUpdated = await this.db.use(this.model, tx).getMany(condition, { projection: ["id"] });
+                const tobeUpdated = await this.db
+                    .use(this.model, tx)
+                    .getMany(condition, { projection: [...(queries?.returning || []), "id"] });
                 modified = tobeUpdated.records.map((r) => r.id);
-                updatedRecords = modified.map((id) => ({ id }));
+                updatedRecords = tobeUpdated.records;
             }
         }
         //-- body.update here had been modified by uri handling
-        const records = updatedRecords.map((re) => ({ ...body.update, ...directUpdate, ...re }));
+        const records = updatedRecords.map((re) => ({ ...re, ...body.update, ...directUpdate }));
         //-- update translations
         if (localeOfFields.length) {
             //-- check if there is missing locale entry for localeFields
@@ -519,7 +526,7 @@ export class ModelRepository extends AbstractRepository {
             const updatedToBeKept = await Promise.all(tobeKept
                 .filter((r) => Object.keys(r).length > 1)
                 .map((r) => modelService.updateMany({
-                queries: { returning: true },
+                queries: { returning: ["id"] },
                 principal,
                 ops: [{ _eq: { id: r.id } }],
                 tx,
@@ -658,13 +665,17 @@ export class ModelRepository extends AbstractRepository {
         }
         const condition = allConditions.length ? { _and: [...allConditions, ...(ops || [])] } : {};
         const nestedQueries = this.getNestedQueries(queries);
-        let returning = [];
+        let returning;
         const uriMapperFields = this.modelMetadata.fields.filter((f) => f.uriMapper);
         const localeOfFields = this.modelMetadata.fields.filter((f) => f.multiLocaleColumn);
         if (nestedQueries.length || localeOfFields.length || uriMapperFields.length) {
-            const tobeRemoved = await this.db
-                .use(this.model, tx)
-                .getRecords(condition, { projection: ["id", ...[...localeOfFields, ...uriMapperFields].map((f) => f.name)] }, nestedQueries);
+            const tobeRemoved = await this.db.use(this.model, tx).getRecords(condition, {
+                projection: [
+                    ...(queries?.returning || []),
+                    "id",
+                    ...[...localeOfFields, ...uriMapperFields].map((f) => f.name),
+                ],
+            }, nestedQueries);
             await this.db.use(this.model, tx).deleteMany({
                 _in: { id: tobeRemoved.map((r) => r.id) },
             });
@@ -718,8 +729,8 @@ export class ModelRepository extends AbstractRepository {
             returning = tobeRemoved;
         }
         else {
-            returning = await this.db.use(this.model, tx).deleteMany(condition, queries?.returning);
+            returning = (await this.db.use(this.model, tx).deleteMany(condition, queries?.returning));
         }
-        return { modified: returning };
+        return { modified: returning || [] };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/server",
-    "version": "3.19.7",
+    "version": "3.20.1",
     "description": "Claire server NodeJs framework written in Typescript.",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",
@@ -17,7 +17,7 @@
     "dependencies": {
         "@clairejs/client": "^3.4.1",
         "aws-sdk": "^2.841.0",
-        "axios": "^0.21.4",
+        "axios": "^1.6.2",
         "cookie-parser": "^1.4.6",
         "cors": "^2.8.5",
         "express": "^4.17.1",
@@ -34,8 +34,8 @@
         "ws": "^7.5.5"
     },
     "peerDependencies": {
-        "@clairejs/core": "^3.8.2",
-        "@clairejs/orm": "^3.15.10"
+        "@clairejs/core": "^3.8.4",
+        "@clairejs/orm": "^3.16.0"
     },
     "devDependencies": {
         "@types/cookie-parser": "^1.4.3",