chore: Deletes AI cruft

Author: NeedleInAJayStack

Package.swift

@@ -1,5 +1,4 @@
-// swift-tools-version: 6.2
-// The swift-tools-version declares the minimum version of Swift required to build this package.
+// swift-tools-version: 6.0
 
 import PackageDescription
 

README.md

@@ -1,28 +1,8 @@
 # GraphQL Generator for Swift
 
-A Swift package plugin that generates server-side GraphQL API code from GraphQL schema files, inspired by [swift-openapi-generator](https://github.com/apple/swift-openapi-generator).
+A Swift package plugin that generates server-side GraphQL API code from GraphQL schema files, inspired by [GraphQL Tools' makeExecutableSchema](https://the-guild.dev/graphql/tools/docs/generate-schema).
 
-This tool uses [GraphQL Swift](https://github.com/GraphQLSwift/GraphQL) to generate type-safe Swift code from your GraphQL schemas, eliminating boilerplate while maintaining full control over your business logic.
-
-## Status
-
-🚧 **Phase 1 Complete** - Foundation is in place with basic code generation
-
-Currently implemented:
-- ✅ Build plugin for SPM integration
-- ✅ GraphQL schema parsing using GraphQL Swift's `buildSchema`
-- ✅ Type generation (Swift structs from GraphQL types)
-- ✅ Resolver protocol generation
-- ✅ Basic runtime library with ResolverContext
-- ✅ CLI tool for code generation
-
-Still in development (see [plan.md](plan.md)):
-- ⏳ Complete schema builder generation (Phase 5)
-- ⏳ Mutations and subscriptions support
-- ⏳ Custom scalar mappings
-- ⏳ Configuration file support
-- ⏳ Complete test coverage
-- ⏳ Working end-to-end examples
+This tool uses [GraphQL Swift](https://github.com/GraphQLSwift/GraphQL) to generate type-safe Swift code and protocol stubs from your GraphQL schema files, eliminating boilerplate while maintaining full control over your business logic.
 
 ## Features
 
@@ -32,20 +12,14 @@ Still in development (see [plan.md](plan.md)):
 - **Modern Swift**: Uses async/await for all resolver functions
 - **Minimal boilerplate**: Generates only ceremony code - you write the business logic
 
-## Requirements
-
-- Swift 6.2+
-- macOS 13+, iOS 16+, tvOS 16+, or watchOS 9+
-- GraphQL Swift 4.0+
-
 ## Installation
 
 Add the package to your `Package.swift`:
 
 ```swift
 dependencies: [
     .package(url: "https://github.com/GraphQLSwift/GraphQL.git", from: "4.0.0"),
-    .package(url: "https://github.com/YourOrg/graphql-generator", from: "1.0.0")
+    .package(url: "https://github.com/GraphQLSwift/graphql-generator", from: "1.0.0")
 ],
 targets: [
     .target(
@@ -84,143 +58,78 @@ type Query {
 ### 2. Build Your Project
 
 When you build, the plugin will automatically generate Swift code:
-- `Types.swift` - Swift structs for your GraphQL types
-- `Resolvers.swift` - Protocol defining resolver methods
-- `Schema.swift` - Schema builder (coming in Phase 5)
+- `Types.swift` - Swift protocols for your GraphQL types
+- `Schema.swift` - Schema
 
-### 3. Implement the Resolver Protocol
+### 3. Create required types
 
-```swift
-import GraphQL
-import GraphQLGeneratorRuntime
-
-struct MyResolvers: GraphQLResolvers {
-    func user(id: String, context: ResolverContext) async throws -> User? {
-        // Your business logic here
-        return User(id: id, name: "John Doe", email: "john@example.com")
-    }
+Create a type named `Context`:
 
-    func users(context: ResolverContext) async throws -> [User] {
-        // Your business logic here
-        return [
-            User(id: "1", name: "Alice", email: "alice@example.com"),
-            User(id: "2", name: "Bob", email: "bob@example.com"),
-        ]
-    }
+```swift
+public actor Context {
+    // Add any features you like
 }
 ```
 
-### 4. Execute GraphQL Queries
+Create any scalar types (with names matching GraphQL), and conform them to `Scalar`:
 
 ```swift
-import GraphQL
-
-// Create resolvers
-let resolvers = MyResolvers()
-
-// Build schema (Phase 5 - not yet implemented)
-// let schema = try buildGraphQLSchema(resolvers: resolvers)
-
-// Execute a query
-// let result = try await graphql(schema: schema, request: "{ users { name email } }")
-// print(result)
-```
-
-## Project Structure
-
-```
-graphql-generator/
-├── Package.swift
-├── README.md
-├── plan.md                           # Detailed implementation plan
-├── Plugins/
-│   └── GraphQLGeneratorPlugin.swift  # SPM build plugin
-├── Sources/
-│   ├── GraphQLGenerator/             # CLI executable
-│   ├── GraphQLGeneratorCore/         # Parsing and generation logic
-│   │   ├── Parser/
-│   │   │   └── SchemaParser.swift
-│   │   └── Generator/
-│   │       ├── CodeGenerator.swift
-│   │       ├── TypeGenerator.swift
-│   │       ├── ResolverGenerator.swift
-│   │       └── SchemaGenerator.swift
-│   └── GraphQLGeneratorRuntime/      # Runtime support library
-│       └── ResolverContext.swift
-├── Tests/
-│   └── GraphQLGeneratorTests/
-└── Examples/
-    └── HelloWorldServer/
+struct DateTime: Scalar {}
 ```
 
-## Generated Code Examples
-
-### From this GraphQL schema:
-
-```graphql
-type User {
-  id: ID!
-  name: String!
-  email: String!
+Create a resolvers struct with the required typealiases:
+```swift
+struct Resolvers: ResolversProtocol {
+    typealias Query = ExamplePackage.Query
+    typealias Mutation = ExamplePackage.Mutation
 }
 ```
 
-### Generates this Swift code:
+As you build the `Query` and `Mutation` types and their resolution logic, you will be forced to define a concrete type for every reachable GraphQL result, according to its generated protocol.
+Here's a small example of a schema that allows querying for the current user, who is only identified by an email address:
 
 ```swift
-// Types.swift
-public struct User: Codable {
-    public let id: String
-    public let name: String
-    public let email: String
-
-    public init(
-        id: String,
-        name: String,
-        email: String
-    ) {
-        self.id = id
-        self.name = name
-        self.email = email
+struct Query: QueryProtocol {
+    // This is required by `QueryProtocol`, and used by GraphQL query resolution.
+    static func user(context: Context, info: GraphQLResolveInfo) async throws -> (any UserProtocol)? {
+        // You can implement resolution logic however you like.
+        return context.user
     }
 }
 
-// Resolvers.swift
-public protocol GraphQLResolvers {
-    func user(id: String, context: ResolverContext) async throws -> User?
-    func users(context: ResolverContext) async throws -> [User]
+struct User: UserProtocol {
+    // You can define the type internals however you like
+    let email: String
+
+    // This is required by `UserProtocol`, and used by GraphQL field resolution.
+    func email(context: Context, info: GraphQL.GraphQLResolveInfo) async throws -> String {
+        // You can implement resolution logic however you like.
+        return email
+    }
 }
 ```
 
-## Development Roadmap
-
-See [plan.md](plan.md) for the complete implementation plan across 8 phases:
-
-- **Phase 1: Foundation** ✅ - Basic infrastructure and plugin setup
-- **Phase 2: Schema Parsing** - Complete SDL parsing (in progress)
-- **Phase 3: Type Generation** - Full type generation with all GraphQL constructs
-- **Phase 4: Resolver Generation** - Complete resolver protocol generation
-- **Phase 5: Schema Builder** - Generate executable GraphQL schema
-- **Phase 6: Advanced Features** - Mutations, subscriptions, custom scalars
-- **Phase 7: Runtime & Ergonomics** - Helper utilities and patterns
-- **Phase 8: Examples & Documentation** - Complete examples and guides
-
-## Contributing
+### 4. Execute GraphQL Queries
 
-This project is in active development. Contributions are welcome!
+```swift
+import GraphQL
 
-## License
+let schema = try buildGraphQLSchema(resolvers: Resolvers.self)
 
-TBD
+// Execute a query
+let result = try await graphql(schema: schema, request: "{ users { name email } }")
+print(result)
+```
 
-## Inspiration
+## Development Roadmap
 
-This project is inspired by:
-- [swift-openapi-generator](https://github.com/apple/swift-openapi-generator) - Build plugin architecture
-- [GraphQL Swift](https://github.com/GraphQLSwift/GraphQL) - Runtime GraphQL implementation
+1. Default values: Default values are currently ignored
+2. Directives: Directives are currently not supported
+3. Subscription: Subscription definitions are currently ignored
+4. Improved testing: Generator tests should cover much more of the functionality
+5. Additional examples: Ideally large ones that cover significant GraphQL features
+6. Executable Schema: To work around the immutability of some Schema components, we generate Swift code to fully recreate the defined schema. Instead, we could just add resolver logic to the schema parsed from the `.graphql` file SDL.
 
-## Related Projects
+## Contributing
 
-- [GraphQL Swift](https://github.com/GraphQLSwift/GraphQL) - The Swift GraphQL implementation
-- [Vapor](https://github.com/vapor/vapor) - Server-side Swift framework
-- [Hummingbird](https://github.com/hummingbird-project/hummingbird) - Lightweight server framework
+This project is in active development. Contributions are welcome!