@el-j/magic-helix-plugins 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/swift/templates/framework-vapor.md

@@ -0,0 +1,352 @@
+# Vapor Framework Instructions
+
+## Server-Side Swift Web Framework
+
+Vapor is a modern, high-performance web framework for Swift.
+
+## Project Structure
+```
+Sources/
+├── App/
+│   ├── Controllers/
+│   ├── Models/
+│   ├── Migrations/
+│   ├── configure.swift
+│   └── routes.swift
+└── Run/
+    └── main.swift
+Tests/
+    └── AppTests/
+Package.swift
+```
+
+## Basic Application
+
+### configure.swift
+```swift
+import Vapor
+import Fluent
+import FluentPostgresDriver
+
+public func configure(_ app: Application) async throws {
+    // Database
+    app.databases.use(
+        .postgres(
+            hostname: Environment.get("DATABASE_HOST") ?? "localhost",
+            port: Environment.get("DATABASE_PORT").flatMap(Int.init) ?? 5432,
+            username: Environment.get("DATABASE_USERNAME") ?? "postgres",
+            password: Environment.get("DATABASE_PASSWORD") ?? "",
+            database: Environment.get("DATABASE_NAME") ?? "vapor"
+        ),
+        as: .psql
+    )
+    
+    // Migrations
+    app.migrations.add(CreateUser())
+    
+    try await app.autoMigrate()
+    
+    // Routes
+    try routes(app)
+}
+```
+
+### routes.swift
+```swift
+import Vapor
+
+func routes(_ app: Application) throws {
+    app.get { req in
+        "Welcome to Vapor!"
+    }
+    
+    app.get("hello", ":name") { req -> String in
+        let name = req.parameters.get("name")!
+        return "Hello, \(name)!"
+    }
+    
+    try app.register(collection: UserController())
+}
+```
+
+## Models with Fluent ORM
+
+```swift
+import Fluent
+import Vapor
+
+final class User: Model, Content {
+    static let schema = "users"
+    
+    @ID(key: .id)
+    var id: UUID?
+    
+    @Field(key: "name")
+    var name: String
+    
+    @Field(key: "email")
+    var email: String
+    
+    @Children(for: \.$user)
+    var posts: [Post]
+    
+    init() {}
+    
+    init(id: UUID? = nil, name: String, email: String) {
+        self.id = id
+        self.name = name
+        self.email = email
+    }
+}
+
+// Migration
+struct CreateUser: AsyncMigration {
+    func prepare(on database: Database) async throws {
+        try await database.schema("users")
+            .id()
+            .field("name", .string, .required)
+            .field("email", .string, .required)
+            .unique(on: "email")
+            .create()
+    }
+    
+    func revert(on database: Database) async throws {
+        try await database.schema("users").delete()
+    }
+}
+```
+
+## Controllers
+
+```swift
+import Vapor
+
+struct UserController: RouteCollection {
+    func boot(routes: RoutesBuilder) throws {
+        let users = routes.grouped("api", "users")
+        users.get(use: index)
+        users.get(":id", use: show)
+        users.post(use: create)
+        users.put(":id", use: update)
+        users.delete(":id", use: delete)
+    }
+    
+    func index(req: Request) async throws -> [User] {
+        try await User.query(on: req.db).all()
+    }
+    
+    func show(req: Request) async throws -> User {
+        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
+            throw Abort(.notFound)
+        }
+        return user
+    }
+    
+    func create(req: Request) async throws -> User {
+        let user = try req.content.decode(User.self)
+        try await user.save(on: req.db)
+        return user
+    }
+    
+    func update(req: Request) async throws -> User {
+        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
+            throw Abort(.notFound)
+        }
+        
+        let updateData = try req.content.decode(User.self)
+        user.name = updateData.name
+        user.email = updateData.email
+        try await user.save(on: req.db)
+        return user
+    }
+    
+    func delete(req: Request) async throws -> HTTPStatus {
+        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
+            throw Abort(.notFound)
+        }
+        try await user.delete(on: req.db)
+        return .noContent
+    }
+}
+```
+
+## Middleware
+
+```swift
+import Vapor
+
+struct LogMiddleware: AsyncMiddleware {
+    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
+        request.logger.info("\(request.method) \(request.url.path)")
+        let response = try await next.respond(to: request)
+        request.logger.info("Response: \(response.status.code)")
+        return response
+    }
+}
+
+// Register middleware
+app.middleware.use(LogMiddleware())
+```
+
+## Authentication
+
+```swift
+import Vapor
+import Fluent
+
+final class User: Model, Content, Authenticatable {
+    // ... model definition
+    
+    static func authenticator() -> Authenticator {
+        return BearerAuthenticator()
+    }
+}
+
+// Protected route
+let protected = app.grouped(User.authenticator())
+protected.get("protected") { req -> String in
+    let user = try req.auth.require(User.self)
+    return "Hello, \(user.name)!"
+}
+```
+
+## Validation
+
+```swift
+import Vapor
+
+struct CreateUserRequest: Content, Validatable {
+    var name: String
+    var email: String
+    
+    static func validations(_ validations: inout Validations) {
+        validations.add("name", as: String.self, is: !.empty)
+        validations.add("email", as: String.self, is: .email)
+    }
+}
+
+func create(req: Request) async throws -> User {
+    try CreateUserRequest.validate(content: req)
+    let userData = try req.content.decode(CreateUserRequest.self)
+    // ...
+}
+```
+
+## Testing
+
+```swift
+import XCTVapor
+@testable import App
+
+final class UserTests: XCTestCase {
+    var app: Application!
+    
+    override func setUp() async throws {
+        app = Application(.testing)
+        try await configure(app)
+    }
+    
+    override func tearDown() async throws {
+        app.shutdown()
+    }
+    
+    func testGetUsers() async throws {
+        try await app.test(.GET, "api/users") { res in
+            XCTAssertEqual(res.status, .ok)
+            let users = try res.content.decode([User].self)
+            XCTAssertGreaterThan(users.count, 0)
+        }
+    }
+    
+    func testCreateUser() async throws {
+        let user = User(name: "John", email: "john@example.com")
+        
+        try await app.test(.POST, "api/users", beforeRequest: { req in
+            try req.content.encode(user)
+        }, afterResponse: { res in
+            XCTAssertEqual(res.status, .ok)
+            let created = try res.content.decode(User.self)
+            XCTAssertEqual(created.name, "John")
+        })
+    }
+}
+```
+
+## Docker Production Setup
+
+```dockerfile
+FROM swift:5.9-jammy AS build
+WORKDIR /app
+
+COPY Package.swift Package.resolved ./
+RUN swift package resolve
+
+COPY . .
+RUN swift build -c release --static-swift-stdlib
+
+FROM ubuntu:22.04
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    libcurl4 \
+    libxml2 \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=build /app/.build/release/Run ./Run
+
+RUN useradd -m -u 1000 vapor
+USER vapor
+
+EXPOSE 8080
+ENV VAPOR_ENV=production
+
+ENTRYPOINT ["./Run"]
+CMD ["serve", "--hostname", "0.0.0.0", "--port", "8080"]
+```
+
+## Environment Configuration
+
+```swift
+import Vapor
+
+func configure(_ app: Application) async throws {
+    switch app.environment {
+    case .production:
+        app.logger.logLevel = .warning
+    case .development:
+        app.logger.logLevel = .debug
+    default:
+        break
+    }
+    
+    // Database URL from environment
+    if let databaseURL = Environment.get("DATABASE_URL") {
+        try app.databases.use(.postgres(url: databaseURL), as: .psql)
+    }
+}
+```
+
+## Performance Tips
+
+- Use async/await throughout
+- Leverage connection pooling
+- Implement caching where appropriate
+- Use database indexes
+- Profile with Instruments
+- Enable release optimizations
+- Use EventLoopFuture batching for multiple operations
+- Implement pagination for large datasets
+
+## Best Practices
+
+- Use proper error handling with `Abort`
+- Validate user input
+- Implement authentication/authorization
+- Use migrations for database schema changes
+- Write comprehensive tests
+- Use environment variables for configuration
+- Implement health check endpoints
+- Log appropriately
+- Use middlewares for cross-cutting concerns
+- Keep controllers thin, logic in services

package/dist/swift/templates/lang-swift.md

@@ -0,0 +1,291 @@
+# Swift Language Instructions
+
+## Project Type
+- Language: Swift
+- Package Manager: Swift Package Manager (SPM)
+- Platform: {iOS|macOS|Linux|Server}
+
+## Build Commands
+
+### Swift Package Manager
+```bash
+swift build              # Build project
+swift test               # Run tests
+swift run                # Run executable
+swift package update     # Update dependencies
+swift package clean      # Clean build artifacts
+```
+
+### Xcode
+```bash
+xcodebuild -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 15'
+xcodebuild test -scheme MyApp
+```
+
+## Code Conventions
+
+### Swift Basics
+```swift
+// Variables and constants
+var mutableValue = 42
+let constantValue = 100
+
+// Optionals
+var name: String? = "John"
+if let unwrappedName = name {
+    print(unwrappedName)
+}
+
+// Nil coalescing
+let displayName = name ?? "Anonymous"
+
+// Optional chaining
+let length = user?.name?.count
+```
+
+### Structs and Classes
+```swift
+struct User {
+    let id: UUID
+    var name: String
+    var email: String
+    
+    func fullProfile() -> String {
+        "\(name) <\(email)>"
+    }
+}
+
+class UserRepository {
+    private var users: [User] = []
+    
+    func add(_ user: User) {
+        users.append(user)
+    }
+    
+    func find(by id: UUID) -> User? {
+        users.first { $0.id == id }
+    }
+}
+```
+
+### Protocols and Extensions
+```swift
+protocol Identifiable {
+    var id: UUID { get }
+}
+
+extension User: Identifiable {}
+
+extension String {
+    func toSnakeCase() -> String {
+        // Implementation
+    }
+}
+```
+
+### Async/Await (Concurrency)
+```swift
+func fetchUser(id: UUID) async throws -> User {
+    let (data, _) = try await URLSession.shared.data(from: url)
+    return try JSONDecoder().decode(User.self, from: data)
+}
+
+// Usage
+Task {
+    do {
+        let user = try await fetchUser(id: userId)
+        print(user.name)
+    } catch {
+        print("Error: \(error)")
+    }
+}
+```
+
+### Error Handling
+```swift
+enum UserError: Error {
+    case notFound
+    case invalidEmail
+}
+
+func getUser(id: UUID) throws -> User {
+    guard let user = findUser(id) else {
+        throw UserError.notFound
+    }
+    return user
+}
+
+// Usage
+do {
+    let user = try getUser(id: userId)
+} catch UserError.notFound {
+    print("User not found")
+} catch {
+    print("Unknown error: \(error)")
+}
+```
+
+## Testing with XCTest
+
+```swift
+import XCTest
+@testable import MyApp
+
+final class UserTests: XCTestCase {
+    func testUserFullProfile() {
+        let user = User(
+            id: UUID(),
+            name: "John",
+            email: "john@example.com"
+        )
+        
+        XCTAssertEqual(user.fullProfile(), "John <john@example.com>")
+    }
+    
+    func testAsyncFunction() async throws {
+        let user = try await fetchUser(id: testUserId)
+        XCTAssertEqual(user.name, "John")
+    }
+}
+```
+
+## Docker for Server-Side Swift
+
+### Multi-stage Dockerfile
+```dockerfile
+# Build stage
+FROM swift:5.9-jammy AS build
+WORKDIR /app
+
+COPY Package.swift Package.resolved ./
+RUN swift package resolve
+
+COPY . .
+RUN swift build -c release --static-swift-stdlib
+
+# Runtime stage
+FROM ubuntu:22.04
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    libcurl4 \
+    libxml2 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=build /app/.build/release/MyApp ./
+
+RUN useradd -m -u 1000 swift
+USER swift
+
+EXPOSE 8080
+CMD ["./MyApp"]
+```
+
+### Docker Compose
+```yaml
+services:
+  app:
+    build: .
+    ports:
+      - "8080:8080"
+    environment:
+      - DATABASE_URL=postgresql://postgres:password@db/myapp
+    depends_on:
+      - db
+  
+  db:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_PASSWORD: password
+```
+
+## Package.swift Structure
+
+```swift
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "MyApp",
+    platforms: [
+        .macOS(.v13),
+        .iOS(.v16),
+        .linux
+    ],
+    products: [
+        .executable(name: "MyApp", targets: ["MyApp"]),
+        .library(name: "MyLibrary", targets: ["MyLibrary"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/vapor/vapor.git", from: "4.89.0")
+    ],
+    targets: [
+        .executableTarget(
+            name: "MyApp",
+            dependencies: [
+                .product(name: "Vapor", package: "vapor")
+            ]
+        ),
+        .testTarget(
+            name: "MyAppTests",
+            dependencies: ["MyApp"]
+        )
+    ]
+)
+```
+
+## Memory Management
+
+```swift
+// ARC (Automatic Reference Counting)
+class User {
+    var name: String
+    init(name: String) { self.name = name }
+}
+
+// Weak references to avoid retain cycles
+class ViewController {
+    weak var delegate: UserDelegate?
+}
+
+// Unowned for guaranteed non-nil references
+class Order {
+    unowned let customer: Customer
+}
+```
+
+## Performance Tips
+
+- Use value types (structs) for immutable data
+- Leverage copy-on-write for collections
+- Use `lazy` for expensive computations
+- Profile with Instruments
+- Use `@inlinable` for small, frequently-called functions
+- Prefer `async/await` over completion handlers
+- Use actors for thread-safe state
+
+## Common Frameworks
+
+### iOS/macOS
+- **SwiftUI**: Modern declarative UI
+- **Combine**: Reactive programming
+- **CoreData**: Persistence
+- **URLSession**: Networking
+
+### Server-Side
+- **Vapor**: Web framework
+- **Fluent**: ORM
+- **PostgresNIO**: PostgreSQL driver
+- **AsyncHTTPClient**: HTTP client
+
+## Best Practices
+
+- Use optionals appropriately
+- Prefer value types over reference types
+- Use guard statements for early returns
+- Implement proper error handling
+- Write unit tests
+- Use protocols for abstraction
+- Follow Swift naming conventions
+- Use type inference wisely
+- Leverage Swift's type safety