diff --git a/src/applicator.ts b/src/applicator.ts
index a27d198..e8332d1 100644
--- a/src/applicator.ts
+++ b/src/applicator.ts
@@ -41,12 +41,10 @@ function wrapResolverInMiddleware<TSource, TContext, TArgs>(
 }
 
 function parseField(field: GraphQLField<any, any, any>) {
-  const argsMap = field.args.reduce(
-    (acc, cur) => ({
-      ...acc,
-      [cur.name]: cur,
-    }),
-    {} as Record<string, GraphQLArgument>,
+  const argsMap = Object.fromEntries(
+    field.args.map(
+      (cur) => [cur.name, cur]
+    )
   )
   return {
     ...field,
@@ -130,34 +128,28 @@ function applyMiddlewareToType<TSource, TContext, TArgs>(
   middleware:
     | IMiddlewareFunction<TSource, TContext, TArgs>
     | IMiddlewareFieldMap<TSource, TContext, TArgs>,
-): IResolvers {
+): Record<string, IResolverOptions> {
   const fieldMap = type.getFields()
 
   if (isMiddlewareFunction(middleware)) {
-    const resolvers = Object.keys(fieldMap).reduce(
-      (resolvers, fieldName) => ({
-        ...resolvers,
-        [fieldName]: applyMiddlewareToField(
-          fieldMap[fieldName],
+    const resolvers = Object.fromEntries(
+      Object.entries(fieldMap).map(([fieldName, field]) => [
+        fieldName,
+        applyMiddlewareToField(
+          field,
           options,
           middleware as IMiddlewareFunction<TSource, TContext, TArgs>,
         ),
-      }),
-      {},
+      ]),
     )
 
     return resolvers
   } else {
-    const resolvers = Object.keys(middleware).reduce(
-      (resolvers, field) => ({
-        ...resolvers,
-        [field]: applyMiddlewareToField(
-          fieldMap[field],
-          options,
-          middleware[field],
-        ),
-      }),
-      {},
+    const resolvers = Object.fromEntries(
+      Object.entries(middleware).map(([fieldName, middlewareFn]) => [
+        fieldName,
+        applyMiddlewareToField(fieldMap[fieldName], options, middlewareFn),
+      ]),
     )
 
     return resolvers
@@ -171,23 +163,21 @@ function applyMiddlewareToSchema<TSource, TContext, TArgs>(
 ): IResolvers {
   const typeMap = schema.getTypeMap()
 
-  const resolvers = Object.keys(typeMap)
-    .filter(
-      (type) =>
-        isGraphQLObjectType(typeMap[type]) &&
-        !isIntrospectionType(typeMap[type]),
-    )
-    .reduce(
-      (resolvers, type) => ({
-        ...resolvers,
-        [type]: applyMiddlewareToType(
-          typeMap[type] as GraphQLObjectType,
+  const resolvers = Object.fromEntries(
+    Object.entries(typeMap)
+      .filter(
+        ([, typeValue]) =>
+          isGraphQLObjectType(typeValue) && !isIntrospectionType(typeValue),
+      )
+      .map(([typeName, type]) => [
+        typeName,
+        applyMiddlewareToType(
+          type as GraphQLObjectType,
           options,
           middleware,
         ),
-      }),
-      {},
-    )
+      ]),
+  )
 
   return resolvers
 }
@@ -212,18 +202,17 @@ export function generateResolverFromSchemaAndMiddleware<
   } else {
     const typeMap = schema.getTypeMap()
 
-    const resolvers = Object.keys(middleware).reduce(
-      (resolvers, type) => ({
-        ...resolvers,
-        [type]: applyMiddlewareToType(
-          typeMap[type] as GraphQLObjectType,
+    const resolvers = Object.fromEntries(
+      Object.entries(middleware).map(([typeName, middlewareFn]) => [
+        typeName,
+        applyMiddlewareToType(
+          typeMap[typeName] as GraphQLObjectType,
           options,
-          middleware[type],
+          middlewareFn,
         ),
-      }),
-      {},
+      ]),
     )
 
     return resolvers
   }
-}
\ No newline at end of file
+}