@punks/backend-entity-manager 0.0.391 → 0.0.393

package/dist/cjs/types/abstractions/serializer.d.ts

@@ -2,6 +2,7 @@
 export type EntryValidationError = {
     errorCode: string;
     value?: any;
+    payload?: any;
 };
 export type EntryValidationResult = {
     isValid: boolean;

package/dist/cjs/types/commands/upsert.d.ts

@@ -3,10 +3,9 @@ import { EntityServiceLocator } from "../providers/services";
 export declare class EntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData> implements IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    execute(id: TEntityId, data: TEntityUpdateData): Promise<{
-        id: TEntityId;
+    execute(id: TEntityId | undefined, data: TEntityUpdateData): Promise<{
+        id: any;
     }>;
-    private upsertEntity;
     private adaptEntity;
     private authorize;
     private getContext;

package/dist/esm/index.js

@@ -1100,37 +1100,53 @@ class EntityUpsertCommand {
         this.services = services;
     }
     async execute(id, data) {
-        const entity = await this.adaptEntity(data);
+        const entity = await this.adaptEntity(id, data);
         await this.authorize(id, entity);
-        const updatedEntity = await this.upsertEntity(id, entity);
-        await this.versionEntity(id, updatedEntity);
+        if (id) {
+            const updatedEntity = await this.services
+                .resolveRepository()
+                .upsert(id, entity);
+            await this.versionEntity(id, updatedEntity);
+            await this.services
+                .resolveEventsManager()
+                .processEntityUpdatedEvent(updatedEntity);
+            return {
+                id,
+            };
+        }
+        const createdItem = await this.services.resolveRepository().create(entity);
+        // todo: parametrize id field
+        const newId = createdItem.id;
+        await this.versionEntity(newId, createdItem);
         await this.services
             .resolveEventsManager()
-            .processEntityUpdatedEvent(updatedEntity);
+            .processEntityCreatedEvent(createdItem);
         return {
-            id,
+            id: newId,
         };
     }
-    async upsertEntity(id, entity) {
-        return await this.services.resolveRepository().upsert(id, entity);
-    }
-    async adaptEntity(input) {
+    async adaptEntity(id, input) {
         const context = await this.getContext();
         const adapter = this.services.resolveAdapter();
-        return adapter
+        if (!adapter) {
+            return input;
+        }
+        return id
             ? adapter.updateDataToEntity(input, context)
-            : input;
+            : adapter.createDataToEntity(input, context);
     }
     async authorize(id, entity) {
         const authorization = this.services.resolveAuthorizationMiddleware();
         if (!authorization) {
             return;
         }
-        const currentEntity = await this.services.resolveRepository().get(id);
         const context = await this.getContext();
         if (!context) {
             return;
         }
+        const currentEntity = id
+            ? await this.services.resolveRepository().get(id)
+            : undefined;
         if (currentEntity) {
             const updateResult = await authorization.canUpdate(currentEntity, context);
             if (!updateResult.isAuthorized)
@@ -40747,18 +40763,30 @@ const fieldTextValidator = (item, selector, params) => {
     const isRequiredValid = params.required
         ? typeof value === "string" && value.length >= 0
         : true;
-    const isMinLengthValid = typeof value === "string" && value.length >= (params.minLength ?? 0);
-    const isMaxLengthValid = typeof value === "string" && value.length <= (params.maxLength ?? Infinity);
+    const length = typeof value === "string" ? value.length : 0;
+    const isMinLengthValid = length >= (params.minLength ?? 0);
+    const isMaxLengthValid = length <= (params.maxLength ?? Infinity);
     const isRegexValid = (typeof value === "string" && params.regex?.test(value)) ?? true;
     return {
         isValid: isMinLengthValid && isMaxLengthValid,
         validationErrors: [
             ...(isRequiredValid ? [] : [{ errorCode: "required" }]),
-            ...(isMinLengthValid && isMaxLengthValid
+            ...(isMinLengthValid
                 ? []
-                : [{ errorCode: "length" }]),
-            ...(isMinLengthValid ? [] : [{ errorCode: "minLength" }]),
-            ...(isMaxLengthValid ? [] : [{ errorCode: "maxLength" }]),
+                : [
+                    {
+                        errorCode: "minLength",
+                        payload: { current: length, expected: params.minLength },
+                    },
+                ]),
+            ...(isMaxLengthValid
+                ? []
+                : [
+                    {
+                        errorCode: "maxLength",
+                        payload: { current: length, expected: params.maxLength },
+                    },
+                ]),
             ...(isRegexValid ? [] : [{ errorCode: "regex" }]),
         ],
     };