ga-plugins-cli 0.1.0 → 0.1.1

package/plugins/go-scaffolder/reference-service/internal/repository/booking_postgres.go

@@ -0,0 +1,124 @@
+package repository
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"github.com/jmoiron/sqlx"
+
+	"github.com/zokypesch/booking-service/internal/domain"
+)
+
+// postgresBookingRepo implements domain.BookingRepository using PostgreSQL via sqlx.
+// All methods accept a context.Context and propagate cancellation and deadlines to the DB.
+type postgresBookingRepo struct {
+	db *sqlx.DB
+}
+
+// NewPostgresBookingRepo constructs a BookingRepository backed by the given *sqlx.DB.
+// db must not be nil.
+func NewPostgresBookingRepo(db *sqlx.DB) domain.BookingRepository {
+	if db == nil {
+		panic("repository: db must not be nil")
+	}
+	return &postgresBookingRepo{db: db}
+}
+
+// Create inserts a new booking row. The booking's ID must already be set by the caller.
+func (r *postgresBookingRepo) Create(ctx context.Context, booking *domain.Booking) error {
+	query := `
+		INSERT INTO bookings (id, customer_id, flight_id, status, seat_count, total_price, created_at, updated_at)
+		VALUES (:id, :customer_id, :flight_id, :status, :seat_count, :total_price, :created_at, :updated_at)`
+
+	_, err := r.db.NamedExecContext(ctx, query, booking)
+	if err != nil {
+		return fmt.Errorf("repository.Create: %w", err)
+	}
+	return nil
+}
+
+// GetByID retrieves a single booking by primary key.
+// Returns domain.ErrBookingNotFound when no matching row exists.
+func (r *postgresBookingRepo) GetByID(ctx context.Context, id string) (*domain.Booking, error) {
+	query := `
+		SELECT id, customer_id, flight_id, status, seat_count, total_price, created_at, updated_at
+		FROM bookings
+		WHERE id = $1`
+
+	booking := &domain.Booking{}
+	err := r.db.GetContext(ctx, booking, query, id)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, domain.ErrBookingNotFound
+		}
+		return nil, fmt.Errorf("repository.GetByID: %w", err)
+	}
+	return booking, nil
+}
+
+// Update replaces all mutable columns of an existing booking row.
+// Returns domain.ErrBookingNotFound when no matching row exists.
+func (r *postgresBookingRepo) Update(ctx context.Context, booking *domain.Booking) error {
+	query := `
+		UPDATE bookings
+		SET    customer_id = :customer_id,
+		       flight_id   = :flight_id,
+		       status      = :status,
+		       seat_count  = :seat_count,
+		       total_price = :total_price,
+		       updated_at  = :updated_at
+		WHERE  id = :id`
+
+	result, err := r.db.NamedExecContext(ctx, query, booking)
+	if err != nil {
+		return fmt.Errorf("repository.Update: %w", err)
+	}
+
+	rows, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("repository.Update rows affected: %w", err)
+	}
+	if rows == 0 {
+		return domain.ErrBookingNotFound
+	}
+	return nil
+}
+
+// List returns a paginated slice of bookings ordered by created_at descending.
+func (r *postgresBookingRepo) List(ctx context.Context, limit, offset int) ([]*domain.Booking, error) {
+	query := `
+		SELECT id, customer_id, flight_id, status, seat_count, total_price, created_at, updated_at
+		FROM   bookings
+		ORDER  BY created_at DESC
+		LIMIT  $1
+		OFFSET $2`
+
+	bookings := []*domain.Booking{}
+	err := r.db.SelectContext(ctx, &bookings, query, limit, offset)
+	if err != nil {
+		return nil, fmt.Errorf("repository.List: %w", err)
+	}
+	return bookings, nil
+}
+
+// Delete permanently removes a booking row.
+// Returns domain.ErrBookingNotFound when no matching row exists.
+func (r *postgresBookingRepo) Delete(ctx context.Context, id string) error {
+	query := `DELETE FROM bookings WHERE id = $1`
+
+	result, err := r.db.ExecContext(ctx, query, id)
+	if err != nil {
+		return fmt.Errorf("repository.Delete: %w", err)
+	}
+
+	rows, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("repository.Delete rows affected: %w", err)
+	}
+	if rows == 0 {
+		return domain.ErrBookingNotFound
+	}
+	return nil
+}

package/plugins/go-scaffolder/reference-service/internal/usecase/booking.go

@@ -0,0 +1,181 @@
+package usecase
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"go.uber.org/zap"
+
+	"github.com/zokypesch/booking-service/internal/domain"
+)
+
+type bookingUsecase struct {
+	repo   domain.BookingRepository
+	logger *zap.Logger
+}
+
+// NewBookingUsecase constructs a BookingUsecase backed by the given repository.
+// Both repo and logger are required; panics if either is nil.
+func NewBookingUsecase(repo domain.BookingRepository, logger *zap.Logger) domain.BookingUsecase {
+	if repo == nil {
+		panic("usecase: repo must not be nil")
+	}
+	if logger == nil {
+		panic("usecase: logger must not be nil")
+	}
+	return &bookingUsecase{repo: repo, logger: logger}
+}
+
+// CreateBooking validates input, assigns a new UUID, and persists a PENDING booking.
+func (uc *bookingUsecase) CreateBooking(ctx context.Context, input domain.CreateBookingInput) (*domain.Booking, error) {
+	if err := uc.validateCreateInput(input); err != nil {
+		return nil, err // already wrapped as domain.ErrInvalidInput
+	}
+
+	now := time.Now().UTC()
+	booking := &domain.Booking{
+		ID:         uuid.NewString(),
+		CustomerID: input.CustomerID,
+		FlightID:   input.FlightID,
+		SeatCount:  input.SeatCount,
+		TotalPrice: input.TotalPrice,
+		Status:     domain.StatusPending,
+		CreatedAt:  now,
+		UpdatedAt:  now,
+	}
+
+	if err := uc.repo.Create(ctx, booking); err != nil {
+		return nil, fmt.Errorf("usecase.CreateBooking: %w", err)
+	}
+
+	uc.logger.Info("booking created",
+		zap.String("booking_id", booking.ID),
+		zap.String("customer_id", booking.CustomerID),
+		zap.String("flight_id", booking.FlightID),
+	)
+
+	return booking, nil
+}
+
+// GetBooking retrieves a single booking by its ID.
+func (uc *bookingUsecase) GetBooking(ctx context.Context, id string) (*domain.Booking, error) {
+	if id == "" {
+		return nil, fmt.Errorf("%w: id is required", domain.ErrInvalidInput)
+	}
+
+	booking, err := uc.repo.GetByID(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("usecase.GetBooking: %w", err)
+	}
+
+	return booking, nil
+}
+
+// UpdateBooking applies a partial update to a booking's mutable fields.
+// Status transitions are NOT allowed through this method; use CancelBooking.
+func (uc *bookingUsecase) UpdateBooking(ctx context.Context, id string, input domain.UpdateBookingInput) (*domain.Booking, error) {
+	if id == "" {
+		return nil, fmt.Errorf("%w: id is required", domain.ErrInvalidInput)
+	}
+
+	booking, err := uc.repo.GetByID(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("usecase.UpdateBooking: %w", err)
+	}
+
+	// Apply only the fields provided in the input (pointer-based partial update).
+	if input.SeatCount != nil {
+		if *input.SeatCount < 1 {
+			return nil, fmt.Errorf("%w: seat_count must be at least 1", domain.ErrInvalidInput)
+		}
+		booking.SeatCount = *input.SeatCount
+	}
+	if input.TotalPrice != nil {
+		if *input.TotalPrice < 0 {
+			return nil, fmt.Errorf("%w: total_price must not be negative", domain.ErrInvalidInput)
+		}
+		booking.TotalPrice = *input.TotalPrice
+	}
+
+	booking.UpdatedAt = time.Now().UTC()
+
+	if err := uc.repo.Update(ctx, booking); err != nil {
+		return nil, fmt.Errorf("usecase.UpdateBooking: %w", err)
+	}
+
+	uc.logger.Info("booking updated",
+		zap.String("booking_id", booking.ID),
+	)
+
+	return booking, nil
+}
+
+// ListBookings returns a paginated list of bookings.
+// limit is capped at 100 to prevent unbounded queries.
+func (uc *bookingUsecase) ListBookings(ctx context.Context, limit, offset int) ([]*domain.Booking, error) {
+	const maxLimit = 100
+	if limit <= 0 || limit > maxLimit {
+		limit = maxLimit
+	}
+	if offset < 0 {
+		offset = 0
+	}
+
+	bookings, err := uc.repo.List(ctx, limit, offset)
+	if err != nil {
+		return nil, fmt.Errorf("usecase.ListBookings: %w", err)
+	}
+
+	return bookings, nil
+}
+
+// CancelBooking transitions a booking from its current status to CANCELLED.
+// Returns domain.ErrInvalidStatus if the transition is not allowed.
+func (uc *bookingUsecase) CancelBooking(ctx context.Context, id string) (*domain.Booking, error) {
+	if id == "" {
+		return nil, fmt.Errorf("%w: id is required", domain.ErrInvalidInput)
+	}
+
+	booking, err := uc.repo.GetByID(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("usecase.CancelBooking: %w", err)
+	}
+
+	if !booking.Status.CanTransitionTo(domain.StatusCancelled) {
+		return nil, fmt.Errorf("%w: cannot cancel a booking with status %s",
+			domain.ErrInvalidStatus, booking.Status)
+	}
+
+	booking.Status = domain.StatusCancelled
+	booking.UpdatedAt = time.Now().UTC()
+
+	if err := uc.repo.Update(ctx, booking); err != nil {
+		return nil, fmt.Errorf("usecase.CancelBooking: %w", err)
+	}
+
+	uc.logger.Info("booking cancelled",
+		zap.String("booking_id", booking.ID),
+		zap.String("customer_id", booking.CustomerID),
+	)
+
+	return booking, nil
+}
+
+// validateCreateInput checks that all required fields are present and valid.
+func (uc *bookingUsecase) validateCreateInput(input domain.CreateBookingInput) error {
+	if input.CustomerID == "" {
+		return fmt.Errorf("%w: customer_id is required", domain.ErrInvalidInput)
+	}
+	if input.FlightID == "" {
+		return fmt.Errorf("%w: flight_id is required", domain.ErrInvalidInput)
+	}
+	if input.SeatCount < 1 {
+		return fmt.Errorf("%w: seat_count must be at least 1", domain.ErrInvalidInput)
+	}
+	if input.TotalPrice < 0 {
+		return fmt.Errorf("%w: total_price must not be negative", domain.ErrInvalidInput)
+	}
+	return nil
+}

package/plugins/go-standards/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "go-standards",
+  "version": "0.1.0",
+  "description": "Single source of truth for Go coding standards across all 30 migrated services.",
+  "skills": [
+    { "name": "project-layout", "path": "skills/project-layout.md" },
+    { "name": "error-handling", "path": "skills/error-handling.md" },
+    { "name": "http-chi", "path": "skills/http-chi.md" },
+    { "name": "config", "path": "skills/config.md" },
+    { "name": "logging-observability", "path": "skills/logging-observability.md" },
+    { "name": "concurrency", "path": "skills/concurrency.md" },
+    { "name": "testing", "path": "skills/testing.md" },
+    { "name": "naming-and-style", "path": "skills/naming-and-style.md" }
+  ],
+  "commands": [
+    {
+      "name": "go-standards-check",
+      "description": "Assess a Go file against GA coding standards",
+      "path": "commands/go-standards-check.md"
+    }
+  ]
+}

package/plugins/go-standards/commands/go-standards-check.md

@@ -0,0 +1,232 @@
+# Command: go-standards-check
+
+Assess a Go source file against the GA coding standards for all 30 migrated
+services. Produces a structured checklist report with PASS / WARN / FAIL per
+category and actionable line-level feedback.
+
+---
+
+## Usage
+
+```
+/go-standards-check [path/to/file.go]
+```
+
+If no path is provided as an argument, ask the user:
+
+> Which Go file would you like me to assess? Please provide the absolute or
+> relative path.
+
+---
+
+## Instructions for Claude Code
+
+When this command is invoked, follow these steps exactly:
+
+### Step 1 — Resolve the target file
+
+If the user provided a path as an argument, use it directly.
+If not, prompt the user for a path before proceeding.
+
+### Step 2 — Read the file
+
+Read the entire contents of the specified `.go` file using the Read tool.
+Also scan for related files that might be relevant to the assessment:
+- The directory listing of the file's parent folder (to check project layout)
+- Any sibling `*_test.go` file for the same type (to check test coverage)
+
+### Step 3 — Assess against each of the 8 standard categories
+
+For each category below, apply the described checks and assign a rating:
+
+- **PASS** — fully compliant, no issues found
+- **WARN** — minor deviation; does not break the standard but should be addressed
+- **FAIL** — clear violation of the standard; must be fixed before merge
+
+---
+
+#### Category 1: Project Layout
+
+Checks:
+- Is the file in the correct directory for its role?
+  - Handlers → `internal/handler/`
+  - Usecases → `internal/usecase/`
+  - Repositories → `internal/repository/`
+  - Domain types/errors → `internal/domain/`
+  - Config → `config/`
+  - Entrypoint → `cmd/server/main.go`
+- Does `main.go` contain any business logic (queries, HTTP handler logic, if/else on domain data)?
+- Does a handler file import `repository/` directly (bypassing usecase)?
+- Does a domain file import any non-stdlib package?
+
+#### Category 2: Error Handling
+
+Checks:
+- Are there any `panic()` calls outside of `main.go` init code?
+- Are errors wrapped with `%w` (not `%v` or `errors.New` around another error)?
+- Are sentinel errors defined in `domain/errors.go` and used for expected cases?
+- Is there any function that both logs an error AND returns it (log-and-return anti-pattern)?
+- Are `sql.ErrNoRows` (and similar infra errors) mapped to domain sentinels at the repository layer?
+- Does any error message start with a capital letter or end with a period or exclamation mark?
+- Are there any ignored errors (`_ = someFunc()` on error-returning calls that are not intentional)?
+
+#### Category 3: HTTP / chi Conventions
+
+Checks:
+- Does every handler method have the signature `func (h *XHandler) Method(w http.ResponseWriter, r *http.Request)`?
+- Is `json.NewDecoder(r.Body).Decode()` called without a `MaxBytesReader` wrapper?
+- Are response helpers (`respondJSON`, `respondError`) used consistently, or is `json.NewEncoder(w).Encode()` called ad hoc?
+- Is the error response body in the form `{"error": "...", "code": "..."}` with a machine-readable code?
+- Are string-keyed context values used (instead of typed keys)?
+- Does any handler contain business logic (validation rules, calculations, data transformation beyond HTTP concerns)?
+- Are URL parameters extracted via `chi.URLParam(r, "id")` (not `r.FormValue` or manual path splitting)?
+- Are `/health` and `/ready` endpoints present and unprotected by auth middleware?
+
+#### Category 4: Config Management
+
+Checks:
+- Are there any calls to `os.Getenv()` outside of `config/config.go`?
+- Are there any hardcoded hostnames, ports, credentials, or API keys?
+- Is a `Config` struct present with env tags?
+- Is the config loaded once and passed to constructors (not re-read in middleware or handlers)?
+- Are secrets (passwords, tokens) included in any log call or error message?
+- Is there a `.env.example` in the service root? (Check via directory listing if possible.)
+- Does the `Config` struct have a safe `String()` method that omits secrets?
+
+#### Category 5: Logging and Observability
+
+Checks:
+- Are there any `fmt.Println`, `fmt.Printf`, `log.Println`, or `log.Printf` calls in non-main code?
+- Are all log calls using structured fields (`zap.String(...)`, `zap.Error(...)`, etc.) rather than interpolated strings?
+- Is `zap.Error(err)` always included when logging an error-level event?
+- Are trace IDs or request IDs included in error-level log calls?
+- Are Prometheus metrics registered with `promauto` (package-level vars) rather than inside functions?
+- Are metric names following the pattern `<service>_<subsystem>_<metric>_<unit>`?
+- Are OpenTelemetry spans created for usecase operations with `.Start()` / `defer span.End()`?
+- Are errors recorded on spans via `span.RecordError(err)`?
+
+#### Category 6: Concurrency Safety
+
+Checks:
+- Does every function that performs I/O accept `context.Context` as its first argument?
+- Is there any `context.WithTimeout` or `context.WithCancel` where the cancel function is not called (or discarded with `_`)?
+- Are there any goroutines launched without a clear termination mechanism (no `ctx.Done()`, no done channel)?
+- Is any goroutine launched inside an HTTP handler using `r.Context()` without `context.WithoutCancel`?
+- Are shared maps or slices accessed from multiple goroutines without `sync.Mutex` or `sync.RWMutex`?
+- Is `sync.WaitGroup.Add()` called outside the goroutine (correctly)?
+- Are loop variables passed to goroutines via explicit capture (`u := u`)?
+
+#### Category 7: Testing Patterns
+
+Checks (assess the paired `_test.go` file if it exists; if absent, flag):
+- Is there a `_test.go` file for this file?
+- Are tests table-driven (slice of test cases + `t.Run`)?
+- Is `testify/assert` and `testify/require` used (not bare `t.Errorf`)?
+- Are dependencies injected as interfaces so they can be mocked?
+- Is `time.Sleep` called in any test?
+- Are integration tests guarded with `//go:build integration`?
+- Is `t.Parallel()` called in table-driven sub-tests where safe?
+- Are handler tests using `httptest.NewRecorder` and `httptest.NewRequest`?
+
+#### Category 8: Naming and Style
+
+Checks:
+- Are package names lowercase, single-word, no underscores?
+- Are there any `Manager`, `Helper`, `Util`, `Abstract`, `Base`, or `Impl` suffixes on exported types?
+- Do interface names follow the `er` suffix (single method) or capability-noun (multi-method) convention?
+- Are receiver names short and consistent (not `self`, not `this`)?
+- Are constructors named `NewX`?
+- Are there getters named `GetFoo()` or setters named `SetFoo()`?
+- Is the `I` prefix used on any interface name?
+- Are there any `utils.go`, `helpers.go`, `common.go`, or `models.go` files visible in the directory?
+- Do error messages follow lowercase, no trailing period convention?
+
+---
+
+### Step 4 — Output the Report
+
+Format the report exactly as shown below. Fill in findings with specific
+line numbers wherever possible.
+
+---
+
+```
+## go-standards-check: <filename>
+
+Assessed: <absolute file path>
+Companion test file: <path or "NOT FOUND — test file missing">
+
+---
+
+### [PASS|WARN|FAIL] 1. Project Layout
+<One-line summary>
+- Line N: <specific finding, or "No issues found.">
+
+### [PASS|WARN|FAIL] 2. Error Handling
+<One-line summary>
+- Line N: <specific finding>
+
+### [PASS|WARN|FAIL] 3. HTTP / chi Conventions
+<One-line summary>
+- Line N: <specific finding>
+
+### [PASS|WARN|FAIL] 4. Config Management
+<One-line summary>
+- Line N: <specific finding>
+
+### [PASS|WARN|FAIL] 5. Logging and Observability
+<One-line summary>
+- Line N: <specific finding>
+
+### [PASS|WARN|FAIL] 6. Concurrency Safety
+<One-line summary>
+- Line N: <specific finding>
+
+### [PASS|WARN|FAIL] 7. Testing Patterns
+<One-line summary>
+- Line N: <specific finding or note about missing test file>
+
+### [PASS|WARN|FAIL] 8. Naming and Style
+<One-line summary>
+- Line N: <specific finding>
+
+---
+
+### Summary
+
+| Category              | Rating |
+|-----------------------|--------|
+| Project Layout        | PASS   |
+| Error Handling        | FAIL   |
+| HTTP / chi            | WARN   |
+| Config Management     | PASS   |
+| Logging/Observability | WARN   |
+| Concurrency Safety    | PASS   |
+| Testing Patterns      | FAIL   |
+| Naming and Style      | PASS   |
+
+**Overall: <PASS if all PASS | WARN if any WARN and no FAIL | FAIL if any FAIL>**
+
+### Required Changes Before Merge
+<Numbered list of FAIL items only. If none, write "None — ready to merge.">
+1. ...
+2. ...
+
+### Recommended Improvements
+<Numbered list of WARN items. If none, omit this section.>
+1. ...
+```
+
+---
+
+## Behavior Notes for Claude Code
+
+- Be precise with line numbers — read the file carefully before assigning ratings.
+- If a category is not applicable to the file type (e.g., HTTP checks on a domain struct file),
+  mark it PASS with a note: "N/A — domain-only file, no HTTP concerns."
+- If the paired test file is missing, always mark Category 7 as FAIL.
+- Do not fabricate findings. If a check cannot be determined from the file alone
+  (e.g., whether Prometheus metrics are registered elsewhere), note the limitation:
+  "Cannot verify — metric registration not visible in this file."
+- After the report, offer to fix any FAIL items:
+  > Would you like me to fix the FAIL items now?