Code Generation Plugin

[samisuteria]

I have a plugin for Graphiti that takes a schema file and generates Swift models, a resolver protocol, and a Graphiti schema. I was wondering if there is any interest in bringing that into the Graphiti package. https://github.com/NoDevOrg/GraphQLTools. It is a bit opinionated on how to structure models and is missing some functionality (like unions).

It can take a schema file

"ISO8601 Formatted"
scalar DateTime
scalar ID

type Message {
    id: ID!
    body: String!
    received: DateTime!
}

type Query {
    listMessages(room: String!): [Message!]!
}

type Mutation {
    sendMessage(room: String!, body: String!): Message!
}

type Subscription {
    listenMessages(room: String!): Message!
}

and it generates the following code

//
// DO NOT EDIT.
// swift-format-ignore-file
//
// Generated by GraphQLSchemaCodeGen
//

import Foundation
import GraphQL
import Graphiti
import Pioneer

enum ChatSchema {}

// MARK: - Error
struct ChatSchemaError: Error {
  let description: String
}

// MARK: - SDL
extension ChatSchema {
  static let sdl: String =
  """
  "ISO8601 Formatted"
  scalar DateTime
  scalar ID

  type Message {
      id: ID!
      body: String!
      sender: Sender!
      received: DateTime!
  }

  type User {
      id: ID!
  }

  type System {
      id: ID!
  }

  union Sender = User | System

  type Query {
      listMessages(room: String!): [Message!]!
  }

  type Mutation {
      sendMessage(room: String!, body: String!): Message!
  }

  type Subscription {
      listenMessages(room: String!): Message!
  }

  extend schema @link(url: "https://specs.apollo.dev/federation/v2.0", import: [])
  """
}

// MARK: - Type Mapping
extension ChatSchema {
  typealias DateTime = Foundation.Date
}

// MARK: - Types
extension ChatSchema {
  struct Message: Codable, Sendable {
    let id: ID
    let body: String
    let sender: Sender
    let received: DateTime
  }

  struct User: Codable, Sendable {
    let id: ID
  }

  struct System: Codable, Sendable {
    let id: ID
  }
}

// MARK: - Resolver Arguments
extension ChatSchema {
  struct ListMessagesArguments: Codable {
    let room: String
  }

  struct SendMessageArguments: Codable {
    let room: String
    let body: String
  }

  struct ListenMessagesArguments: Codable {
    let room: String
  }
}

// MARK: - Resolver Protocol
extension ChatSchema {
  protocol ChatResolver: Sendable {
    associatedtype ContextType

    func listMessages(context: ContextType, args: ListMessagesArguments) async throws -> [Message]
    func sendMessage(context: ContextType, args: SendMessageArguments) async throws -> Message
    func listenMessages(context: ContextType, args: ListenMessagesArguments) async throws -> EventStream<Message>
  }
}

// MARK: - Resolver Default Implemention
extension ChatSchema.ChatResolver {
  func listMessages(context: ContextType, args: ChatSchema.ListMessagesArguments) async throws -> [ChatSchema.Message] {
    throw ChatSchemaError(description: "Resolver for query.listMessages is unimplemented.")
  }

  func sendMessage(context: ContextType, args: ChatSchema.SendMessageArguments) async throws -> ChatSchema.Message {
    throw ChatSchemaError(description: "Resolver for mutation.sendMessage is unimplemented.")
  }

  func listenMessages(context: ContextType, args: ChatSchema.ListenMessagesArguments) async throws -> EventStream<ChatSchema.Message> {
    throw ChatSchemaError(description: "Resolver for subscription.listenMessages is unimplemented.")
  }
}

// MARK: - Schema Builder
extension ChatSchema {
  static func schema<Resolver>(coders: Coders = Coders()) throws -> Schema<Resolver, Resolver.ContextType> where Resolver: ChatResolver {
    try SchemaBuilder(Resolver.self, Resolver.ContextType.self)
      .setCoders(to: coders)
      .setFederatedSDL(to: sdl)
      .add {
        Scalar(DateTime.self, as: "DateTime")
          .description("ISO8601 Formatted")
        Scalar(ID.self, as: "ID")
        Type(Message.self, as: "Message") {
          Field("id", at: \.id)
          Field("body", at: \.body)
          Field("sender", at: \.sender)
          Field("received", at: \.received)
        }
        Type(User.self, as: "User") {
          Field("id", at: \.id)
        }
        Type(System.self, as: "System") {
          Field("id", at: \.id)
        }
      }
      .addQuery {
        Field("listMessages", at: Resolver.listMessages) {
          Argument("room", at: \.room)
        }
      }
      .addMutation {
        Field("sendMessage", at: Resolver.sendMessage) {
          Argument("room", at: \.room)
          Argument("body", at: \.body)
        }
      }
      .addSubscription {
        SubscriptionField("listenMessages", as: Message.self, atSub: Resolver.listenMessages) {
          Argument("room", at: \.room)
        }
      }
      .build()
  }
}

[NeedleInAJayStack]

This is awesome! I love that you're making use of the parse(source:) features of the GraphQL package. Somewhat related, I just put in a big MR for full SDL support/tooling last night: GraphQLSwift/GraphQL#154 I'd be interested to know if it simplifies any of this work - it should at least enable us to make our federation SDL generation automatic!

As for bringing this in, I'd be interested. I think we have 2 options:

1. Bring it into the Graphiti package itself.
2. Bring it into the GraphQLSwift org as a separate package.
   I think I lean toward option 2, since I imagine most changes to the existing Graphiti code base and this generator won't impact each other, and separating the packages allows us to version them independently.

[samisuteria]

Oh amazing! I'd love for federation to be automatic :)

[samisuteria]

I'm leaning towards option 2 also but packages like swift-protobuf and grpc-swift add the plugin to the package itself. The grpc ecosystem is very schema first but I'm not sure if the graphql one is. I can see arguments for code-first + making the plugin into a separate package and schema-first + bundling the plugin with Graphiti.

[samisuteria]

Just had a look at your MR and it looks awesome! This would totally help in the code generation plugin and another cli that I'm working on to verify client operations with a schema.