fix(args2request): fix args convertion to request when there is a entity on the use case request

Author: dalssoft

src/args2request.js

@@ -1,10 +1,22 @@
+const { entity, tryParse } = require('@herbsjs/herbs')
+
 function args2request(args, useCase, _info) {
     const isMutation = _info?.operation?.operation === 'mutation'
     if (isMutation && args?.input) args = args.input
     const params = {}
     const fields = Object.keys(useCase.requestSchema)
-    for (const field of fields) params[field] = args[field]
+    for (const field of fields) {
+        const name = field
+        const type = useCase.requestSchema[field]
+        params[name] = parametersCast(args[name], type)
+    }
     return params
 }
 
+function parametersCast(value, type) {
+    if (Array.isArray(type)) return value?.map(item => defaultConvention.parametersCast(item, type[0]))
+    if (entity.isEntity(type) && value) return type.fromJSON(value)
+    return tryParse(value, type)
+}
+
 module.exports = args2request

test/defaultResolver.test.js

@@ -1,5 +1,5 @@
 const assert = require('assert')
-const { Ok, usecase, step, Err } = require('@herbsjs/herbs')
+const { entity, field, usecase, step, request, Ok, Err } = require('@herbsjs/herbs')
 const defaultResolver = require('../src/defaultResolver')
 
 describe('GraphQL - Default Resolver', () => {
@@ -43,6 +43,37 @@ describe('GraphQL - Default Resolver', () => {
         assert.deepStrictEqual(ret, { id: 1 })
     })
 
+    it('should resolve a mutation with complex request and run a use case', async () => {
+        // Given
+        const AnEntity = entity('An Entity', {
+            id: field(Number),
+            field1: field(String)
+        })
+
+        const AnComplexEntity = entity('An Complex Entity', {
+            id: field(Number),
+            field1: field(String),
+            entity1: field(AnEntity)
+        })
+
+        const AUseCase = () =>
+            usecase('Use Case X', {
+                request: request.from(AnComplexEntity),
+                response: Number,
+                authorize: async () => Ok(),
+                'Step 1': step((ctx) => { return Ok(ctx.ret = ctx.req) }
+                )
+            })
+
+        const resolver = defaultResolver(AUseCase)
+
+        // When
+        const ret = await resolver(null, { input: { id: 1, field1: 'xyz', field2: 123, entity1: { id: 1 } } }, { user: {} }, { operation: { operation: 'mutation' } })
+
+        // Then
+        assert.deepStrictEqual(JSON.parse(JSON.stringify(ret)), { id: 1, field1: 'xyz', entity1: { id: 1 } })
+    })
+
     it('should not run a use case if not autorized and throw a ForbiddenError', async () => {
         // Given
         const AUseCase = {