feat: Converts to closure API

Author: NeedleInAJayStack

Sources/Graphiti/Input/Input.swift

@@ -15,7 +15,9 @@ public final class Input<
         let inputObjectType = try GraphQLInputObjectType(
             name: name,
             description: description,
-            fields: fields(typeProvider: typeProvider),
+            fields: {
+                try self.fields(typeProvider: typeProvider)
+            },
             isOneOf: isOneOf
         )
 

Sources/Graphiti/Interface/Interface.swift

@@ -10,7 +10,9 @@ public final class Interface<Resolver, Context, InterfaceType>: TypeComponent<
         let interfaceType = try GraphQLInterfaceType(
             name: name,
             description: description,
-            fields: fields(typeProvider: typeProvider, coders: coders),
+            fields: {
+                try self.fields(typeProvider: typeProvider, coders: coders)
+            },
             resolveType: nil
         )
 

Sources/Graphiti/Mutation/Mutation.swift

@@ -11,7 +11,9 @@ public final class Mutation<Resolver, Context>: Component<Resolver, Context> {
         typeProvider.mutation = try GraphQLObjectType(
             name: name,
             description: description,
-            fields: fields(typeProvider: typeProvider, coders: coders),
+            fields: {
+                try self.fields(typeProvider: typeProvider, coders: coders)
+            },
             isTypeOf: isTypeOf
         )
     }

Sources/Graphiti/Query/Query.swift

@@ -8,34 +8,35 @@ public final class Query<Resolver, Context>: Component<Resolver, Context> {
     }
 
     override func update(typeProvider: SchemaTypeProvider, coders: Coders) throws {
-        var queryFields = try fields(typeProvider: typeProvider, coders: coders)
-
-        // Add federated types and queries if they exist
-        if !typeProvider.federatedTypes.isEmpty {
-            let federatedTypes = typeProvider.federatedTypes
-            guard let sdl = typeProvider.federatedSDL else {
-                throw GraphQLError(message: "If federated types are included, SDL must be provided")
-            }
-
-            // Add subgraph types to provider (_Service, _Any, _Entity)
-            let entity = entityType(federatedTypes)
-            typeProvider.types.append(serviceType)
-            typeProvider.types.append(anyType)
-            typeProvider.types.append(entity)
-
-            // Add subgraph queries (_entities, _service)
-            queryFields["_entities"] = entitiesQuery(
-                for: typeProvider.federatedResolvers,
-                entityType: entity,
-                coders: coders
-            )
-            queryFields["_service"] = serviceQuery(for: sdl)
-        }
-
         typeProvider.query = try GraphQLObjectType(
             name: name,
             description: description,
-            fields: queryFields,
+            fields: {
+                var queryFields = try self.fields(typeProvider: typeProvider, coders: coders)
+
+                // Add federated types and queries if they exist
+                if !typeProvider.federatedTypes.isEmpty {
+                    let federatedTypes = typeProvider.federatedTypes
+                    guard let sdl = typeProvider.federatedSDL else {
+                        throw GraphQLError(message: "If federated types are included, SDL must be provided")
+                    }
+
+                    // Add subgraph types to provider (_Service, _Any, _Entity)
+                    let entity = entityType(federatedTypes)
+                    typeProvider.types.append(serviceType)
+                    typeProvider.types.append(anyType)
+                    typeProvider.types.append(entity)
+
+                    // Add subgraph queries (_entities, _service)
+                    queryFields["_entities"] = entitiesQuery(
+                        for: typeProvider.federatedResolvers,
+                        entityType: entity,
+                        coders: coders
+                    )
+                    queryFields["_service"] = serviceQuery(for: sdl)
+                }
+                return queryFields
+            },
             isTypeOf: isTypeOf
         )
     }

Sources/Graphiti/Subscription/Subscription.swift

@@ -11,7 +11,9 @@ public final class Subscription<Resolver, Context>: Component<Resolver, Context>
         typeProvider.subscription = try GraphQLObjectType(
             name: name,
             description: description,
-            fields: fields(typeProvider: typeProvider, coders: coders),
+            fields: {
+                try self.fields(typeProvider: typeProvider, coders: coders)
+            },
             isTypeOf: isTypeOf
         )
     }

Sources/Graphiti/Type/Type.swift

@@ -13,30 +13,33 @@ public final class Type<Resolver, Context, ObjectType>: TypeComponent<
     }
 
     override func update(typeProvider: SchemaTypeProvider, coders: Coders) throws {
-        let fieldDefs = try fields(typeProvider: typeProvider, coders: coders)
         let objectType = try GraphQLObjectType(
             name: name,
             description: description,
-            fields: fieldDefs,
-            interfaces: interfaces.map {
-                try typeProvider.getInterfaceType(from: $0)
+            fields: {
+                let fields = try self.fields(typeProvider: typeProvider, coders: coders)
+                // Validate federation keys, if present
+                for key in self.keys {
+                    try key.validate(
+                        againstFields: Array(fields.keys),
+                        typeProvider: typeProvider,
+                        coders: coders
+                    )
+                }
+                return fields
+            },
+            interfaces: {
+                try self.interfaces.map {
+                    try typeProvider.getInterfaceType(from: $0)
+                }
             },
             isTypeOf: isTypeOf
         )
 
         try typeProvider.add(type: ObjectType.self, as: objectType)
 
-        // If federation keys are included, validate and create resolver closure
+        // If federation keys are included, create resolver closure
         if !keys.isEmpty {
-            let fieldNames = Array(fieldDefs.keys)
-            for key in keys {
-                try key.validate(
-                    againstFields: fieldNames,
-                    typeProvider: typeProvider,
-                    coders: coders
-                )
-            }
-
             let resolve: GraphQLFieldResolve = { source, args, context, eventLoopGroup, _ in
                 guard let s = source as? Resolver else {
                     throw GraphQLError(

Sources/Graphiti/Union/Union.swift

@@ -8,8 +8,10 @@ public final class Union<Resolver, Context, UnionType>: TypeComponent<Resolver,
             name: name,
             description: description,
             resolveType: nil,
-            types: members.map {
-                try typeProvider.getObjectType(from: $0)
+            types: {
+                try self.members.map {
+                    try typeProvider.getObjectType(from: $0)
+                }
             }
         )