Merged in feature/healthmove (pull request #165)

Move health endpoint from OpenAPI spec to direct implementation

* Move health endpoint from OpenAPI spec to direct implementation

- Removed HealthService tag from OpenAPI spec
- Removed /health path from OpenAPI spec
- Removed health.go and health_test.go files from api/queryAPI
- Added direct health endpoint in internal/server/api/listener.go
- Updated validator options to skip validation for the /health endpoint
- Added test for health endpoint in internal/server/api/listener_test.go
- Regenerated API code from the updated OpenAPI spec
This commit is contained in:
Michael McGuinness
2025-06-10 20:32:10 +00:00
parent e544f08505
commit d4a65ccf78
11 changed files with 280 additions and 423 deletions
+142
View File
@@ -0,0 +1,142 @@
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## General rules DO NOT VIOLATE
NEVER create mock data or simplified components unless explicitly told to do so
NEVER replace existing complex components with simplified versions - always fix the actual problem or the feature that was requested.
ALWAYS work with the existing codebase - do not create new simplified alternatives
ALWAYS find and fix the root cause of issues instead of creating workarounds
When debugging issues, focus on fixing the existing implementation, not replacing it
When something doesn't work, debug and fix it - don't start over with a simple version
Dont build things I am not specifically asking for unless its required to build the thing I am asking for.
When asked to make unit tests avoid mocks and use the actual thing that is being tested when reasonable.
## Essential Commands
### Development Setup
- `devbox shell` - Enter development environment (Nix-based)
- `touch .env` - Create environment variables file
- `task fullsuite` - Complete development workflow (generate, build, lint, test)
### Core Development Tasks
- `task generate` - Generate all code (DB queries via SQLC, OpenAPI clients/servers, mocks, docs)
- `task build` - Build Docker image
- `task lint` - Run all linting (Go, YAML, JSON, Docker, OpenAPI)
- `task go:lint -- --fix` - Fix automatically fixable linting issues in Go code
- `task test:functional` - Run full test suite with 80% coverage threshold
- `task precommit` - Pre-commit checks for CI/CD readiness
### Testing Commands
- `task test:unit:short` - Quick unit tests
- `task test:race` - Race condition detection
- `task test:perf` - Performance analysis with slowest test reporting
- `task test:mem` - Memory usage profiling
- `task test:bench` - Benchmark execution
## Architecture Overview
### System Design
This is a **document processing and query orchestration platform** with microservices architecture using:
- **Event-driven processing** via AWS SQS queues
- **RESTful API** (queryAPI on port 8080) for external interactions
- **Runner services** (ports 8081-8090) as queue consumers
- **PostgreSQL** with migration-driven schema management
- **AWS services** (S3, SQS, Textract, Cognito) for cloud functionality
### Document Processing Pipeline
1. **Upload** → S3 storage → storeEventRunner
2. **Init** → Validation/deduplication → docInitRunner
3. **Sync** → Client eligibility → docSyncRunner
4. **Clean** → Content processing → docCleanRunner
5. **Text Extraction** → AWS Textract OCR → docTextRunner
6. **Query Processing** → Custom queries → queryRunner
7. **Export** → Result generation
### Core Entities
- **Client**: Customer configurations with document sets and permissions
- **Collector**: Query collection specifications per client
- **Query**: Data processing blocks with dependency chains
- **Document**: Uploaded files with processing state tracking
- **Export**: Manual result output processes
### Service Architecture
- **queryAPI** (8080): Main REST API with OpenAPI-generated handlers
- **Runners** (8081-8090): Queue-based processing services implementing `Controller` interface
- Each runner consumes from specific SQS queues
- Stateless processing with database persistence
- Prometheus metrics integration
## Development Patterns
### Code Generation
All code generation happens via `task generate`:
- **SQLC**: Database queries from `internal/database/queries/*.sql`
- **OpenAPI**: API clients/servers from `serviceAPIs/*.yaml`
- **Mockery**: Test mocks for interfaces
- **gomarkdoc**: Documentation generation
### Testing Strategy
- **Testcontainers**: Docker-based integration testing for database/queue interactions
- **80% coverage threshold** (60% function coverage) enforced
- **Private test files**: Use `*private_test.go` for internal testing
- **Mock interfaces**: Auto-generated in `mocks/` directory
### Project Structure
Follows Go Standard Project Layout:
- `cmd/`: Application entry points (main.go files)
- `internal/`: Private application code
- `api/`: Generated API server implementations
- `pkg/`: Generated API client libraries
- `mocks/`: Auto-generated test mocks
### Naming Conventions
- **Service**: Commands deployed as APIs (e.g., queryAPI)
- **Runner**: Commands deployed as queue consumers (e.g., docTextRunner)
- **API naming**: `<functionality>API` format
- **Runner naming**: `<functionality>Runner` format
### Environment Configuration
Environment variable hierarchy (first overrides subsequent):
1. `devbox.json` "env" section
2. `devbox.json` "init_hook" exports
3. `.env` file variables
### Authentication & Authorization
- **AWS Cognito**: JWT-based authentication
- **Permit.io**: RBAC integration for fine-grained permissions
- Middleware handles token validation and permission checking
## Key Dependencies
### Core Technologies
- **Go 1.24**: Primary language
- **PostgreSQL**: Database with pgx driver
- **Echo v4**: HTTP framework with middleware
- **Testcontainers**: Integration testing
- **AWS SDK v2**: Cloud service integration
### Code Quality Tools
- **golangci-lint**: Go linting
- **yamllint**: YAML validation
- **Task**: Build automation
- **devbox**: Development environment
## Quick Start for New Features
### Adding New API Endpoint
1. Modify `serviceAPIs/queryAPI.yaml` OpenAPI specification
2. Run `task generate` to regenerate API code
3. Implement handlers in `api/queryAPI/`
4. Add tests following existing patterns
### Adding New Queue Consumer
1. Create `api/<runnerName>/runner.go` implementing `Controller` interface
2. Create `cmd/<runnerName>/main.go` entry point
3. Add queue configuration in `internal/serviceconfig/queue/`
4. Add to docker-compose and deployment configurations
### Database Changes
1. Add migration files in `internal/database/migrations/`
2. Add queries in `internal/database/queries/`
3. Run `task db:generate` to regenerate Go code
4. Update repository layer as needed
+75 -89
View File
@@ -428,9 +428,6 @@ type ServerInterface interface {
// Check export state.
// (GET /export/{id})
ExportState(ctx echo.Context, id ExportID) error
// Provide health endpoint
// (GET /health)
IsHealthy(ctx echo.Context) error
// Get the home page menu
// (GET /home)
GetHomePage(ctx echo.Context) error
@@ -656,15 +653,6 @@ func (w *ServerInterfaceWrapper) ExportState(ctx echo.Context) error {
return err
}
// IsHealthy converts echo context to params.
func (w *ServerInterfaceWrapper) IsHealthy(ctx echo.Context) error {
var err error
// Invoke the callback with all the unmarshaled arguments
err = w.Handler.IsHealthy(ctx)
return err
}
// GetHomePage converts echo context to params.
func (w *ServerInterfaceWrapper) GetHomePage(ctx echo.Context) error {
var err error
@@ -838,7 +826,6 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL
router.GET(baseURL+"/client/:id/status", wrapper.GetStatusByClientId)
router.GET(baseURL+"/document/:id", wrapper.GetDocument)
router.GET(baseURL+"/export/:id", wrapper.ExportState)
router.GET(baseURL+"/health", wrapper.IsHealthy)
router.GET(baseURL+"/home", wrapper.GetHomePage)
router.GET(baseURL+"/login", wrapper.Login)
router.GET(baseURL+"/login-callback", wrapper.LoginCallback)
@@ -854,82 +841,81 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL
// Base64 encoded, gzipped, json marshaled Swagger object
var swaggerSpec = []string{
"H4sIAAAAAAAC/+xceW8juXL/KkTnAQF2dUs+gyDxs2d2tJhrbU/eS8aOQXWXJO52kxqSbY9m4O8e8OqT",
"rcMjexeIAP9hdfMoFn/1Y7FY7O9ByJIFo0ClCE6/B3PAEXD97yWW8JYkRKofEYiQk4UkjAan+hWK1TtE",
"6JTxBKsXiFBkfqCbQL/9twdCI/bw75Ik0Db/3wRBK4CvOFnEEJwG/V7PFer3glYgwjkkWPXoLXOoyiT4",
"61ugMzkPToeDVrDAUgJXYv3v51775PZnV9j8+lvQCuRyoRoSkhM6Cx4fH1UtjhOQdqznMQEqxxf1oV7P",
"AYX6LRpfdIJWQNTTBZbzoBVQnKh2SRS0Ag5fUsIhCk4lT6E4kr9xmAanwb90c1V3zVvRzTpWMl2wME1W",
"yBHZ988iSaFzJcurrwvGGyUB/fZZ5Mg6VlL8lgJfNgkxvkBsiuQc0BdVbPeiuN41YDiIBaMCNF7GVEEO",
"x684Z1w9CBmVQLWp4MUiJqG2iO7vQkn7fdOhq9begRB4BqbT8qBdr0gAvweOQJVXw26yWl9ntmw3L6h7",
"GtN7HJPoEr6kIOQLDkl3i7jpF01YtNzRiK4Ze4fp0o5IvNiQLi1QULpgFEnGUILp0o1Q7GB0reASJF+2",
"z6YSeN023qfJBLiyDQEho5FAE5gyDkjyJaEzhGeY0E6RhvuDXtEmDIkr26FyODCMS5I0CU6PD0e9XitI",
"CDW/exm3EiphBlwp5LEVfKI4lXPGyTdlcy+t+Ic5UJQWRNgJoh6digorxjmmV0sa1udgbIjJrhxEIBzH",
"7EFrP5TkHpBY0lDkS9OEsRgwVXNrW+aAJfiJb8HZArgkINR6i0JVlDA9pfkrVZVEm68/jjA3Kf9elTSk",
"6Hj1syFa3cZtNiw2+R1CmY9qzQoLXy3B6bZyD+Ds7Kyy7h+W1v2Ob5XP+/w7i5Yr+yXRj+murolmFby3",
"Wm4URquwPHoOEsoKGBxsoYEriWUq6p1eLSAkUwUjhVWhSynawFYUzRFU2fnnYPz+7uq/358HreD9h2v9",
"76uLwo/x+18KY/YL4J+GMzdu23/RoTS6q8+NyAa0fn7s4KtzZJtonqdPi2gTA5RzLFGCl2iiCF9V8WAp",
"xPROWJ5YL7EjlaeZZH04LIL/Ai6I4VqPWwlCaQWFLAJ0b0qqMRSXgcNRcRk4GQyGw6NBb3h4fDA6Ojrs",
"lRaFfn1RUFLEMYSSedar7BVKWARxXX2GMu/u80Gs0ocb62MrMMi6244GpwTiaD24nNCvTfHHVhBjCUI+",
"QUyrubtQLQHAN22hOLGFViR8lU9qomIhufIynTSL2tB9TSmt6mR6DbCkWz9otUTVlVAvua5yHUcbWVOp",
"b2NVrUBvMDbAUb5jKOvScnrWzPpRNy8TLJWLVFoFqIY7T1saKgBu1rLi5LpqiYRkSyvRKMVfx6amltOK",
"hTnHy5JUV+CJO3zEy5jhSM+1JlvtUKHz5il/MnU8mQX+OsZcQ9gFCw3RrV3VKk7AjlazP8kdbeUS3/q1",
"ogMfa2IuuQ48GvmxdabR7jCNtOHd4ziFjOGcSEUn8buTaNnPrNxUy4VdDoLT0SD/OXTREPfgIDj93G8N",
"WsNbH3rmWMzXje+NKrPRTFfCTbWZK64+uudMYavmcG3kzHj6uW/d658cHPeiaXsynB63j4aj4/YJnvTb",
"fTg4mAyn/WOIjoquUJpqiSpbkRq5Onmu0iTBfLlGKGFKrYTYy2pf9+ZTdGkPXhvVRf5LUYiOT5VRmriq",
"wZKlKEmFRISGcRoBwsi9fKwOPmnq0EqCzNOJAr1eqHAqoDzRWXcztftOAM0Yi4qbjScsohXNOSm9etNR",
"zQuQmMRi9cJmY6uSk9kMOHJxxx2xjvEe7mJmQjB+ZLq3auF/mJNwrrVqBftGFmhKYkAPJI7VtmfKUlox",
"KzE87XZx96xr6nQHvcFBb9AfdpX9dEJxX9F2b3RcUreu3/lZ/dkWdDD/+/Fjt/PzzY1qwevUbLYxNJPR",
"sDEsEs+KTeJG8fEGtoH2KDrot4/6w7B9cgzQHh2O4Hh43O9P+8MnsE1pPP6lnQlBJnEmmBqYYRm3v1dq",
"ikFCpKPodwvOZhyEcvmnmMQQeXf3puNrg9TVqLZw1g4btWLUIa0p/m5KYncwU27wtX5hohUhWwCaYAER",
"YtR6w9Y11uue2NhJ1b6baXoDD5XQGQglz1PEzCqj/PyprgWg0V1z8CHGQiL1WlFs1mBpw67etiVJoH5a",
"5jMZLhu7IwJNCd9hh3XPwudrFKekQb3G9Q9ZnCa0To2MRkRu4DMXOjrP6jjn7O7pG0YDQf8EmncoFTBN",
"YySZBooBUwmz2+/pcuj2e70qdCs8Vxhhq6CvTPTb1dNyXtTwCsIxhjnNpizrqcQ+MQhxJ+dY9T/TkW/u",
"foYxExDdESqB3+M4aAVsAbT4O4apvKsX42Q29z23/oYmZvOfj9reWH9rhdtm3dJV61jDPI2jRhfqDAlC",
"ZzEgvVI2RKXLVT5R8iUFRCKgkkwJcONGUEnksrP1crJZLPstEdI5kWK1nvLwQbaf3IiWqz70empWQv2W",
"Aic+yztDAqRisC+mRF23X5qqqnYrNTcagY4GleU+6A/W2KWTwqd106BnaDGbkRCllGg54SuEqf9E6Omh",
"VEanZLbRiM9N0Y02IlnA7AfCp057d4UJXFX10pa3feuojVH1BrJeq4LePZNuohbfrI2rcV7PMw1Xw+Pq",
"ecqNR+6CAFnKwyr6ubn53vnp5ubRS0Km01XHjJmLgtxg1WqljxvVdi0Tobb2bo+UP38Ode3GyWly9LUO",
"mqMKMD08aB8dHh22jyM4aZ+MRsMDfDIcDo/wE/x8IzwIWcjSWHs6bOcJKRC6JIT6pDmyvtsuduBC2tsa",
"bUX3xd6rTTZOiVGE2Rz7NeG2zmjKWVJSRF0BJlZWz3QDkcaylGeUNbD1wl8ZtemyeXwWzqvObFXNWhKU",
"c6p+vfrw/u7VP68vz86vP1wGreD8w/vrV/+8vnv96e1br9Oj+336wWcRb3/20vPjhOLbl9RKNfoKGWMa",
"zIwvtnQbjHWtcXg2OtZtONEtJ/YM+qOj0fHwcHS0JrunFQgIU07k8kqJ6yh/RolkZ6n0+MzqqXJGbUgp",
"Vf4tOkvwN0bRuamIxhcfO2is2NN4jJevz4+PBgfo139co4kirgVX8AktpzkR9Jhi9mDwZdN9dDfnLILa",
"w088Dk6DuZQLcdrtRiz8tuyoAp1UtAEL2e53sJbLjqcTsqTLVIlBN0sm0kmqbGF36gkmqs2zMAQh1OqY",
"CuD/KpB5YfYqilKDX0CiD+OLcyTZH2A3rFNi8juqld0rhUBV+kfkNt0Vwayfq7Z/f5BuxiaAOfDXDh6/",
"/uM6qGZXqanQjSE2kZhQiBCeSuDZHOLSPD91OrUR6IwoLVJOomr4JuuL0ClzSWU4lMV5SJJwlhJKQYj/",
"xJiDBKWLPBn0HQnnGGL0LvzFFgtaQarVa9SqStcSy84+jrPdTNkL06aKPvBwDkJaD00Av1dDU6OJSQh2",
"ebISpNQ+i7KeHx4eOtZ3cP1LIjU0fO2ffRyrXboz/aDX6XX6OrS7AIoXJDgNhp1eZxjoBWmucdoNs3O/",
"BfM5DsYPFAgjCg8uI+eBSBP5XXB2TyKIUGQC2B2DbCPQOMrq29NFw74gpMv42Un6XykvzpP+ZzhPy+f3",
"V8OidHk2cDW3d9Dr71hmm4Hmkdm8tyJGSKSaCqZpHO8qC3bU6zXVyEbdrST/6mr99dVKWZ6q0uBkfaVq",
"Wu5jKzjYTMZiynVxIQpOP3/Pyezz7eNtKxDu4M0iswRsRSp4JpSPZHPEjMkGt6pZayvd7yR6VGLNfJkI",
"lyA5gXttMcK4ZKEzm8kSESlscnzZTH4BWbCREuh6OwNdfszfjLiCIe9B9uMgU6s7Lsz/+GIFxsqXTz77",
"ZcqLFI7vbjWlhx4nyzjtwpytEKETY4osrsDfSN6m8guQt91arCFv5QiZguupuudZysyw3Z5kz6m7h7uZ",
"x+KSuiGfdsNiGugWzJqliFpyLV3JqnOsK/73pTWe6DkJN89t9RFuJvqec5+Dc4vIyFBRRGSeUficBHwF",
"0nWfi7Seeq+awfoMJFxMrlxPwhPQRybexNp1vDxaleatWt3T8u4t4qpsEauNoMrMUSENcg0xKzTENs6V",
"n/JNlsUrTz5mLh0avgw1l88pV/jD2TDUwPaA3A0gdTBUls6CTYi45jdkc7QrlvZGOT4tdD4SdmfsOo3N",
"JmDYO7WaspmugGOUgMQRltjjMquWLvJM3Ga+TtJYkgXmsjtlPGnr5nSST8giQmcm7clkR9pa1zbMW0D9",
"IprqE6ZFrAObUxwLaAVCLnWYSDUc5BcUC+nAWV5VDE2ZxkYFqR5QMUY8IVTNYumco987Gh6N+seDUSG/",
"JD8/UI1R78WFD06jYSokS1BWsnhs5lDSMaMt9DvqnZQSYDo/rz1d0UOuH67UGcCM3ChioqbvSbsOBwWr",
"yB3dOd1zSG6zekJXMkZ1STNZhtoads0kY0ok0TvuQmbsgjPl09QXPpshadIln8m5K+diNnh3VlCLb62+",
"zosGRPPMJ4+Er0qZz/u9+7PYk0VInoVbsCmbSNxoUHl69QYeoljS0F3q3WjXbm8Jv8yWvXovudk1tEPY",
"7953vnt3F79zoDxP1FTB2PkWm4b1ZWEvrG/DZWmfFssm56cG4pJL+HwBftOHB7SZH7LH687xGlV0m0Nh",
"tzuZYoaVBq+9A7MSuudzCP8wuA1Tzh1z6fSg0o2LMmTzuyPwnJAt339qXvvnWKAJAEXZfZQ9gHd0Dqrw",
"Ubr/01mx8m8L2fyrXRqwc8CxySzxYvUKAJFptu0mISAiULrQF155Sqna0FWROhZvdKvLYJP9mC3r2t+j",
"aBsUlZHz0WR/IDOpCGi0YKQUvTHKLvuNc2biAE3rbMqpYas31+/eogRoihZ4Zm45F1KJINJZUcK72L5h",
"CXxUm4m1zCXhq+zOZRKXKauCGSWJrZSFvdU4jGRKxmKARDdXCY+Mjg+OKld1fmr4AmGl76wbJcUerTtb",
"tL1z6ICrqpVhG7MZoY24LW/7dVk0jdmD8gQ4RIRDqI/eJSumNtqCSgBPUFx3WAHwsDfwGY3poNh63nIZ",
"Mm8b7/d+unzrQp7eRjyfgUs5WZPu7HITOz9543J7AK+m21YlhfazyxttBS6R1OWEViPseursfBbcs/UY",
"b4c4jic4/KMR7G8wjWIL9Q+qlQFydVCUcnfZ3qLHxr7QJYRA3A6qlH5rPjClc/GLxqHWfPgazjGdgUDE",
"Mi/7A6hosJZzJ3nNS6lnHq/o3X0vVGdo5zmiqtzKT4auMoTPZ+3/we1vvfbJzU37zv/12VbNHdJ+ejYU",
"rYDzq8vXSqlSMYqeT5+sQvrSZBqE7fcGo62Fvd2WmQogtAnCeRTPYGVLpnK82tza0ynrP5o46/+ts1c1",
"dI+35yUUljafHL9lM0MHypNDLDUxFKM48w0nsxMQQoNG7QH8a6npJ5PJSw9KkB9YTVX72lNQbmgBypkL",
"8WPojZ2Ae8w+05GzmULN89usiV/c1dq1SWlx+TZw8RsU+rMPIScSOMH+/Ad3P/mZcx5cN56dxll1BPu9",
"8Q6zHb5k8+uwpu9wlCIrG9zAMLfGtr6A8Zt1D57jgLF4X/gp1y++FGT7Cxw2mqs1+5sXL3Tzws1+g1Vk",
"FPyEaxfGVlbfusgN45lI137roQln+9OYZ8j9zSa+lPBb59utItnZ7dvtLlsUCHuDuxbPztOrb1qYuxHu",
"Q0TZdyXtheHs/vYT0qAM2vd3L17g7sVWjNqV9nsRP2AMXrfllf7WjCZk84WJlJrz8iYPpvzhs0qeFAj5",
"7KZR/IBGg31UvpixTapU7zmEtR+58ElrZBRpvE9a3lWClFLpevPS7fF7f+TxI2dRGmbXwfU99tRziz9k",
"Sfe+r83L9lNPnLUGorzqWLOqcqp1covIA4HlbJl6iLGhGXctoNhS9arApo1lOd55W7VciE3byndRtqWS",
"9jdtxRx2F1opn3Jv2kz5wwZ5a8UgwqZt2YPxrI3yyenj7eP/BQAA///MtX56kW0AAA==",
"H4sIAAAAAAAC/+xceW8juXL/KkTnAQF2dUs+gyDxs2d2tJhrbU/eS8aOQHWXJO52kxqSbVsz8HcPePXd",
"uix5F4gA/2F18ygWq34sFn/sH57PojmjQKXwzn94M8ABcP3vNZbwnkREqh8BCJ+TuSSMeuf6FQrVO0To",
"hPEIqxeIUGR+oDtPv/23R0ID9vjvkkTQNP/feV7DgycczUPwzr1up+MKdTtewxP+DCKseqwsc6zKRPjp",
"PdCpnHnn/V7Dm2MpgSux/vdrp3l2/7MrbH79zWt4cjFXDQnJCZ16z8/PqhbHEUg71suQAJXDq/JQb2eA",
"fP0WDa9aXsMj6ukcy5nX8CiOVLsk8Boeh28x4RB455LHkB3J3zhMvHPvX9qpqtvmrWgnHSuZrpgfR0vk",
"COz7vUiS6VzJ8uZpznitJKDf7kWOpGMlxW8x8EWdEMMrxCZIzgB9U8V2L4rrXRsMBzFnVIC2lyFVJofD",
"N5wzrh74jEqg2lXwfB4SX3tE+3ehpP2x7tBVax9ACDwF02l+0K5XJIA/AEegyqth13ltVWe2bDstqHsa",
"0gcckuAavsUg5CsOSXeLuOkXjVmw2NGIbhn7gOnCjki82pCuraGgeM4okoyhCNOFG6HYwega3jVIvmhe",
"TCTwsm98jKMxcOUbAnxGA4HGMGEckOQLQqcITzGhrSwMd3udrE8YEFe+Q2W/ZxCXRHHknZ8eDzqdhhcR",
"an53EmwlVMIUuFLIc8P7QnEsZ4yT78rnXlvxjzOgKM6IsBOLenYqyqwYl5jeLKhfnoOhASa7chCBcBiy",
"R619X5IHQGJBfZEuTWPGQsBUza1tmQOWUA18c87mwCUBodZb5KuihOkpTV+pqiRYf/1xgLlO+Y+qpAFF",
"h6tfDdDqNu6TYbHx7+DLdFQrVlh4sgCn20ojgIuLi8K6f5xb91tVq3za599ZsFjaLwlepruyJupV8NFq",
"uVYYrcL86DlIyCugd7SBBm4klrEod3ozB59MlBkpWxW6lIINbEXRGEGVn3/1hh9HN//98dJreB8/3ep/",
"31xlfgw//pIZc7UA1dNw4cZt+88GlEZ35bkRyYBWz48dfHGObBP18/RlHqzjgHKGJYrwAo0V4KsqFbbk",
"YzoSFidWS+xAZTuXLA+HBfBfwAUxWFsRVoJQWkE+CwA9mJJqDNll4HiQXQbOer1+/6TX6R+fHg1OTo47",
"uUWhW14UlBRhCL5kFetV8gpFLICwrD4DmaOHdBDL9OHG+tzwjGWNNoPBCYEwWG1cTui3pvhzwwuxBCG3",
"ENNqbuSrJQD4ui1kJzbTioQnuVUTBQ9JlZfopF7Umu5LSmkUJ7PSAXO6rTZaLVFxJdRLrqtctqO1vCnX",
"t/Gqhqc3GGvYUbpjyOvSYnrSzOpR1y8TLJbzWFoFqIZb2y0NBQOu17LC5LJqiYRoQy/RVoqfhqamltOK",
"hTnHi5xUN1CRd/iMFyHDgZ5rDbY6oEKX9VO+NXRsjQJ/HWcuWdgV8w3QrVzVCkHAjlazPykcbaQS31dr",
"RSc+VuRcUh1UaORl60yt32EaaMd7wGEMCcI5kbJB4g8n0aKbeLmplgq76Hnng176s++yIe7BkXf+tdvo",
"Nfr3VdYzw2K2anzvVJm1ZrqQbirNXHb10T0nCls2hyszZybST2PrTvfs6LQTTJrj/uS0edIfnDbP8Ljb",
"7MLR0bg/6Z5CcJINheJYS1TYipTA1clzE0cR5osVQglTaqmJva72dW9Vis7twUujukp/KQjR+am8lUau",
"qrdgMYpiIRGhfhgHgDByL5+Lg4/qOrSSIPN0rIxeL1Q4FpCf6KS7qdp9R4CmjAXZzcYWi2hBc07KSr3p",
"rOYVSExCsXxhs7lVycl0Chy5vOOOUMdED6OQmRRMtWW6t2rhf5wRf6a1agX7TuZoQkJAjyQM1bZnwmJa",
"cCvRP2+3cfuibeq0e53eUafX7beV/7R88VDQdmdwmlO3rt/6Wf3ZFnQy/8fpc7v1892daqEyqFlvY2gm",
"o2ZjmAWeJZvEtfLjNWgDzUFw1G2edPt+8+wUoDk4HsBp/7TbnXT7W6BNbjzVSzsTgozDRDA1MIMybn+v",
"1BSChEBn0UdzzqYchAr5J5iEEFTu7k3Ht8ZSl1u1NWcdsFErRtmkNcSPJiR0BzP5Bt/qFyZb4bM5oDEW",
"ECBGbTRsQ2O97om1g1Qdu5mm14hQCZ2CUPJsI2ZSGaXnT2UtAA1G9cmHEAuJ1GsFsUmDuQ27etuUJILy",
"aVmVy3BZ2x0RaEL4DjssRxZVsUZ2SmrUa0J/n4VxRMvQyGhA5Boxc6ajy6SOC85G228YjQlWT6B5h2IB",
"kzhEkmlDMcaUs9nN93Sp6XY7naLpFnAuM8JGRl+J6PfLp+Uyq+ElgGMcc5JMWdJTDn1CEGIkZ1j1P9WZ",
"b+5++iETEIwIlcAfcOg1PDYHmv0dwkSOysU4mc6qntt4QwOz+a8K2t7ZeGtJ2GbD0mXrWM08DYPaEOoC",
"CUKnISC9UtZkpfNVvlDyLQZEAqCSTAhwE0ZQSeSitfFysl4u+z0R0gWRYrme0vRBsp9cC5aLMfRqaFZC",
"/RYDJ1Wed4EESIVg30yJsm6/1VVV7RZqrjUCnQ3Ky33U7a3wSydFldZNgxVDC9mU+CimRMsJT+DH1SdC",
"26dSGZ2Q6VojvjRF19qIJAmzF6RPnfZGmQlcVvXalrd966yNUfUast6qgpV7Jt1EKb9ZGlftvF4mGi6m",
"x9XzmJuI3CUBEsrDMvi5u/vR+unu7rkShEyny44ZkxAFucGq1UofN6rtWiJCae3d3FL+/DnUtWsnpy7Q",
"1zqozyrA5PioeXJ8ctw8DeCseTYY9I/wWb/fP8FbxPlGeBAyw9JYeTps5wkpI3QkhPKkObAebZY7cCnt",
"TZ22oPts78Uma6fEKMJsjqs14bbOaMJZlFNEWQEmV1ZmuoGIQ5njGSUNbLzwF0ZtuqwfnzXnZWe2qmaJ",
"BOWCql9vPn0cvfnn7fXF5e2na6/hXX76ePvmn7ejt1/ev68MenS/2x98Zu3tz156Xg4oVfuSUqnaWCFB",
"TGMzw6sNwwbjXSsCnrWOdWtOdPPEnl53cDI47R8PTlawexqeAD/mRC5ulLgO8qeUSHYRy4qYWT1VwahN",
"KcUqvkUXEf7OKLo0FdHw6nMLDRV6mojx+u3l6UnvCP36j1s0VsA158p8fItpTgQ9ppA9GvuydB/dzSUL",
"oPTwCw+9c28m5Vyct9sB878vWqpAKxZNwEI2uy2s5bLjafksajNVotdOyESapMrmdqceYaLavPB9EEKt",
"jrEA/q8CmRdmr6Ig1fsFJPo0vLpEkv0BdsM6IYbfUazsXikLVKVfIrfpLmvM+rlq+/dH6WZsDJgDf+vM",
"49d/3HpFdpWaCt0YYmOJCYUA4YkEnswhzs3zttOpnUAzorRIKYiq4RvWF6ET5khl2JfZeYgifxoTSkGI",
"/8SYgwSli5QM+oH4Mwwh+uD/Yot5DS/W6jVqVaVLxLKLz8NkN5OPwrSrok/cn4GQNkITwB/U0NRoQuKD",
"XZ6sBDG1z4Kk58fHx5aNHVz/kkhtGlXtX3weql26c32v0+q0ujq1OweK58Q79/qtTqvv6QVppu207Sfn",
"fnNWFTiYOFAgjCg8OkbOI5Em8zvn7IEEEKDAJLBbxrKNQMMgqW9PFw36gpCO8bMT+l+OF1dB/zOYp+Wr",
"jlf9rHQpG7jI7e11ujuW2TLQKmQ2762IARKxhoJJHIa7YsEOOp26Gsmo2wXyr67WXV0tx/JUlXpnqysV",
"abnPDe9oPRmzlOvsQuSdf/2RgtnX++f7hifcwZu1zJxhK1DBU6FiJMsRMy7r3atmra+0f5DgWYk1rWIi",
"XIPkBB60xwgTkvnObcYLRKSw5Pi8m/wCMuMjOaPr7Mzo0mP+eovLOPLByF5uZGp1x5n5H14tsbH85ZOv",
"1TKlRTLHd/ca0v2KIMsE7cKcrRChiTFZFFfGXwvepvIrgLfdWqwAbxUImYKrobpTsZSZYbs9yQFTd2/u",
"Zh6zS+qaeNr2szTQDZA1oYhacM1dySpjrCv+94V1nmCfgJtyW6sANxH9gLn7wNysZSRWkbXIlFG4TwC+",
"Aem6T0VaDb039ca6BxDOkitXg/AY9JFJJbF2FS4PltG8VasHWN69R9zkPWK5ExSROcjQIFcAs7KG0Oa5",
"0lO+8SJ75akKmXOHhq8DzflzyiXxcDIMNbCDQe7GIHUyVObOgk2KuBQ3JHO0K5SuzHJ8mWs+EnZn7JrG",
"ZgkY9k6thmymK+AQRSBxgCWuCJlVS1cpE7cer6M4lGSOuWxPGI+aujlN8vFZQOjU0J4MO9LWurVp3ozV",
"z4OJPmGahzqxOcGhgIYn5EKniVTDXnpBMUMHTnhVIdQxjY0KYj2gbI54TKiaxdw5R7dz0j8ZdE97gwy/",
"JD0/UI3RyosLn5xG/VhIFqGkZPbYzFlJy4w20++gc5YjwLR+Xnm6oodcPlwpI4AZuVHEWE3fVrsOZwpW",
"kTu6c3rAkNRn9YQuRYzikmZYhtobdo0kQ0ok0TvuDDN2zpmKacoLn2VIGrrknoK7PBezJrqzglr71upr",
"vWpCNGU+VUj4Jsd8Puzd9+JP1kJSFm7GpyyRuNahUnr1GhGiWFDfXepda9dubwm/zpa9eC+5PjS0Qzjs",
"3ne+e3cXv1ND2U/WVJmxiy3WTevLzF5Y34ZLaJ/Wlg3np2TEuZBwfwl+00eF0SZxyMFed26vQUG3qSns",
"dieTZVhp47V3YJaa7uUM/D+M3fox5w65ND0od+Mib7Lp3RHYp8nm7z/Vr/0zLNAYgKLkPsrBgHd0Dqrs",
"I3f/p7Vk5d/UZNOvdmmDnTGzCawD2ZhTY6rvbj+8RxHQGM3x1FxxzfBIINCUGFGJtO9YBJ9VJLnSbCU8",
"yfZMRmHeXvNSaUlspSTnqcZhJFMyZnfHurnC3nhwenRSuKfxU83n5wp9J90oKQ4GvzPErpxDZ/OqWj7W",
"DdmU0Fq7ze/5dFk0CdmjWgY4BISDr89dJcvy2mxBJUBFRlR3WDDgfqdX5TSmg2zract5k3lfe7nzy/V7",
"l++qbKTiG2AxJyu4ro6Y1vqpMilzMOClBvzcKPAnvzrSYMNzLEJHCCymV/XU2fnMrM2rbbzp4zAcY/+P",
"WmN/h2kQWlP/pFrpIVcHBTF3N62t9djEB7oGH4gLn3PcS/N1IU3EzjoHpgGCJ3+G6RQEIhZ52R9ARY23",
"XDrJS0tUmXa6pHf3sUhNz00Jgqrc0u9FLnOErxfN/8HN753m2d1dc1T96dFG6eBQB2nJULQCLm+u3yql",
"SoUoej6rZBWyiiNRI2y30xtsLOz9psiUMULLDk1TOMZWNkQqh6v1rW0PWf9Rh1n/n9AnByhFRwcazBnJ",
"HdRUAgqL648N37OpgQMVySEWmw20UZz5gI85fRFCGw0N6tZS008iUyU8KEFesJqq9nWkoMLQjCknIcTL",
"rDd0Ah5sdk/njWYKNc5vsiZ+c/cqVzKSwvxV0OwHCPSdf58TCZzg6sNvdzl1zwferpuKncZFcQSH7fUO",
"j7q/JfPrbE0T+HPb6jXo9+bK0Mbs+99seLCP06XsZdFtuPffMrL9BU6azL2KA+3+lWj3bvZrvCKB4C04",
"98ZXllPuU8fYE+jai/51dnZIxe+B+JlMfI7tWcbbjdKYydXLzZj2GcBeg2i/d5xeTrM3xHj3FZrko4L2",
"tmhyeXcLDoyx9gPx/hWI9xshalvajwW8wBkqw5Y3+kMjGpDN5wViag5L6yKY/FevCiQZEHLvrpH9ekKN",
"fxQ+l7AJT6azD2HtFw6qpDUyijg8MFZ3xY5RKl3tXro9/lCdefzMWRD7yV1gfYk5rrjC7bOo/dDV7mX7",
"KbMmrYOoqDrUqKqCas1sEGkiME+VKKcYa5pxnPBsS0We+LqNJQTftK3SQfi6baW7KNtSTvvrtmJOOjOt",
"5I84120mf6s9bS2bRHi+f/6/AAAA//+RS2POSGsAAA==",
}
// GetSwagger returns the content of the embedded swagger specification file
-11
View File
@@ -1,11 +0,0 @@
package queryapi
import (
"net/http"
"github.com/labstack/echo/v4"
)
func (s *Controllers) IsHealthy(ctx echo.Context) error {
return ctx.NoContent(http.StatusOK)
}
-25
View File
@@ -1,25 +0,0 @@
package queryapi_test
import (
"net/http"
"testing"
queryapi "queryorchestration/api/queryAPI"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestIsHealthy(t *testing.T) {
t.Parallel()
cfg := &ControllerConfig{}
svc := createControllerServices(cfg)
cons := queryapi.NewControllers(svc)
ctx, rec := createContext(t)
err := cons.IsHealthy(ctx)
require.NoError(t, err)
assert.Equal(t, http.StatusOK, rec.Code)
}
+32
View File
@@ -161,6 +161,38 @@
}
}
},
"github:NixOS/nixpkgs/nixpkgs-unstable": {
"last_modified": "2025-06-10T02:39:58Z",
"resolved": "github:NixOS/nixpkgs/cdc68935eba9f86d155585fdf6f17af6824f38ac?lastModified=1749523198&narHash=sha256-How2kQw0psKmCdXgojc95Sf3K5maHB3qfINxTZFCAPM%3D"
},
"glibcLocales@latest": {
"last_modified": "2025-05-16T20:19:48Z",
"resolved": "github:NixOS/nixpkgs/12a55407652e04dcf2309436eb06fef0d3713ef3#glibcLocales",
"source": "devbox-search",
"version": "2.40-66",
"systems": {
"aarch64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/2hb8s2i45cx30qqhayzzsfbg12k8d8fs-glibc-locales-2.40-66",
"default": true
}
],
"store_path": "/nix/store/2hb8s2i45cx30qqhayzzsfbg12k8d8fs-glibc-locales-2.40-66"
},
"x86_64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/d91i3lzpkii5kabfx1kxvl3banc47min-glibc-locales-2.40-66",
"default": true
}
],
"store_path": "/nix/store/d91i3lzpkii5kabfx1kxvl3banc47min-glibc-locales-2.40-66"
}
}
},
"go-migrate@4.18.1": {
"last_modified": "2024-12-23T21:10:33Z",
"resolved": "github:NixOS/nixpkgs/de1864217bfa9b5845f465e771e0ecb48b30e02d#go-migrate",
+8 -1
View File
@@ -5,6 +5,7 @@ import (
"errors"
"log/slog"
"net"
"net/http"
"os"
"strconv"
"time"
@@ -212,6 +213,11 @@ func New(ctx context.Context, cfg Config) (*Server, error) {
e.Use(echoprometheus.NewMiddleware("echo"))
e.GET("/metrics", echoprometheus.NewHandler())
// Health endpoint
e.GET("/health", func(c echo.Context) error {
return c.NoContent(http.StatusOK)
})
e.Use(getSlogCustomEchoMiddleware(cfg.GetLogger()))
e.Use(middleware.Recover())
e.Use(middleware.CORS())
@@ -247,7 +253,8 @@ func setOapi(e *echo.Echo, opnapi *openapi3.T) error {
validatorOptions := &oapimiddleware.Options{
Skipper: func(c echo.Context) bool {
return len(c.Path()) >= 8 && (c.Path()[:8] == "/swagger" ||
c.Path()[:8] == "/metrics")
c.Path()[:8] == "/metrics") ||
c.Path() == "/health"
},
Options: openapi3filter.Options{
AuthenticationFunc: openapi3filter.NoopAuthenticationFunc,
+23
View File
@@ -82,6 +82,29 @@ func TestGetRouter(t *testing.T) {
assert.Equal(t, r, c.Router)
}
func TestHealthEndpoint(t *testing.T) {
// Create a new Echo instance
e := echo.New()
// Register health endpoint
e.GET("/health", func(c echo.Context) error {
return c.NoContent(http.StatusOK)
})
// Create a request to the health endpoint
req := httptest.NewRequest(http.MethodGet, "/health", nil)
rec := httptest.NewRecorder()
// Serve the request
e.ServeHTTP(rec, req)
// Assert the response status code
assert.Equal(t, http.StatusOK, rec.Code)
// Assert the response body is empty
assert.Empty(t, rec.Body.String())
}
func TestGetSlogCustomEchoMiddleware(t *testing.T) {
l := &logger.TestLogger{
T: t,
-73
View File
@@ -841,79 +841,6 @@ func (_c *MockClientInterface_GetStatusByClientId_Call) RunAndReturn(run func(co
return _c
}
// IsHealthy provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) IsHealthy(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for IsHealthy")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_IsHealthy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsHealthy'
type MockClientInterface_IsHealthy_Call struct {
*mock.Call
}
// IsHealthy is a helper method to define mock.On call
// - ctx context.Context
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) IsHealthy(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_IsHealthy_Call {
return &MockClientInterface_IsHealthy_Call{Call: _e.mock.On("IsHealthy",
append([]interface{}{ctx}, reqEditors...)...)}
}
func (_c *MockClientInterface_IsHealthy_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_IsHealthy_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_IsHealthy_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_IsHealthy_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_IsHealthy_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_IsHealthy_Call {
_c.Call.Return(run)
return _c
}
// ListDocumentsByClientId provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) ListDocumentsByClientId(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
@@ -839,79 +839,6 @@ func (_c *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call)
return _c
}
// IsHealthyWithResponse provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientWithResponsesInterface) IsHealthyWithResponse(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*queryapi.IsHealthyResponse, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for IsHealthyWithResponse")
}
var r0 *queryapi.IsHealthyResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.IsHealthyResponse, error)); ok {
return rf(ctx, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *queryapi.IsHealthyResponse); ok {
r0 = rf(ctx, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*queryapi.IsHealthyResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientWithResponsesInterface_IsHealthyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsHealthyWithResponse'
type MockClientWithResponsesInterface_IsHealthyWithResponse_Call struct {
*mock.Call
}
// IsHealthyWithResponse is a helper method to define mock.On call
// - ctx context.Context
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) IsHealthyWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_IsHealthyWithResponse_Call {
return &MockClientWithResponsesInterface_IsHealthyWithResponse_Call{Call: _e.mock.On("IsHealthyWithResponse",
append([]interface{}{ctx}, reqEditors...)...)}
}
func (_c *MockClientWithResponsesInterface_IsHealthyWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_IsHealthyWithResponse_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), variadicArgs...)
})
return _c
}
func (_c *MockClientWithResponsesInterface_IsHealthyWithResponse_Call) Return(_a0 *queryapi.IsHealthyResponse, _a1 error) *MockClientWithResponsesInterface_IsHealthyWithResponse_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientWithResponsesInterface_IsHealthyWithResponse_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.IsHealthyResponse, error)) *MockClientWithResponsesInterface_IsHealthyWithResponse_Call {
_c.Call.Return(run)
return _c
}
// ListDocumentsByClientIdWithResponse provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientWithResponsesInterface) ListDocumentsByClientIdWithResponse(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.ListDocumentsByClientIdResponse, error) {
_va := make([]interface{}, len(reqEditors))
-126
View File
@@ -505,9 +505,6 @@ type ClientInterface interface {
// ExportState request
ExportState(ctx context.Context, id ExportID, reqEditors ...RequestEditorFn) (*http.Response, error)
// IsHealthy request
IsHealthy(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
// GetHomePage request
GetHomePage(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
@@ -722,18 +719,6 @@ func (c *Client) ExportState(ctx context.Context, id ExportID, reqEditors ...Req
return c.Client.Do(req)
}
func (c *Client) IsHealthy(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
req, err := NewIsHealthyRequest(c.Server)
if err != nil {
return nil, err
}
req = req.WithContext(ctx)
if err := c.applyEditors(ctx, req, reqEditors); err != nil {
return nil, err
}
return c.Client.Do(req)
}
func (c *Client) GetHomePage(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
req, err := NewGetHomePageRequest(c.Server)
if err != nil {
@@ -1299,33 +1284,6 @@ func NewExportStateRequest(server string, id ExportID) (*http.Request, error) {
return req, nil
}
// NewIsHealthyRequest generates requests for IsHealthy
func NewIsHealthyRequest(server string) (*http.Request, error) {
var err error
serverURL, err := url.Parse(server)
if err != nil {
return nil, err
}
operationPath := fmt.Sprintf("/health")
if operationPath[0] == '/' {
operationPath = "." + operationPath
}
queryURL, err := serverURL.Parse(operationPath)
if err != nil {
return nil, err
}
req, err := http.NewRequest("GET", queryURL.String(), nil)
if err != nil {
return nil, err
}
return req, nil
}
// NewGetHomePageRequest generates requests for GetHomePage
func NewGetHomePageRequest(server string) (*http.Request, error) {
var err error
@@ -1743,9 +1701,6 @@ type ClientWithResponsesInterface interface {
// ExportStateWithResponse request
ExportStateWithResponse(ctx context.Context, id ExportID, reqEditors ...RequestEditorFn) (*ExportStateResponse, error)
// IsHealthyWithResponse request
IsHealthyWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*IsHealthyResponse, error)
// GetHomePageWithResponse request
GetHomePageWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetHomePageResponse, error)
@@ -2063,31 +2018,6 @@ func (r ExportStateResponse) StatusCode() int {
return 0
}
type IsHealthyResponse struct {
Body []byte
HTTPResponse *http.Response
JSON400 *InvalidRequest
JSON401 *Unauthorized
JSON429 *TooManyRequests
JSON500 *InternalError
}
// Status returns HTTPResponse.Status
func (r IsHealthyResponse) Status() string {
if r.HTTPResponse != nil {
return r.HTTPResponse.Status
}
return http.StatusText(0)
}
// StatusCode returns HTTPResponse.StatusCode
func (r IsHealthyResponse) StatusCode() int {
if r.HTTPResponse != nil {
return r.HTTPResponse.StatusCode
}
return 0
}
type GetHomePageResponse struct {
Body []byte
HTTPResponse *http.Response
@@ -2448,15 +2378,6 @@ func (c *ClientWithResponses) ExportStateWithResponse(ctx context.Context, id Ex
return ParseExportStateResponse(rsp)
}
// IsHealthyWithResponse request returning *IsHealthyResponse
func (c *ClientWithResponses) IsHealthyWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*IsHealthyResponse, error) {
rsp, err := c.IsHealthy(ctx, reqEditors...)
if err != nil {
return nil, err
}
return ParseIsHealthyResponse(rsp)
}
// GetHomePageWithResponse request returning *GetHomePageResponse
func (c *ClientWithResponses) GetHomePageWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetHomePageResponse, error) {
rsp, err := c.GetHomePage(ctx, reqEditors...)
@@ -3135,53 +3056,6 @@ func ParseExportStateResponse(rsp *http.Response) (*ExportStateResponse, error)
return response, nil
}
// ParseIsHealthyResponse parses an HTTP response from a IsHealthyWithResponse call
func ParseIsHealthyResponse(rsp *http.Response) (*IsHealthyResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &IsHealthyResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
var dest InvalidRequest
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON400 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest Unauthorized
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 429:
var dest TooManyRequests
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON429 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
var dest InternalError
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON500 = &dest
}
return response, nil
}
// ParseGetHomePageResponse parses an HTTP response from a GetHomePageWithResponse call
func ParseGetHomePageResponse(rsp *http.Response) (*GetHomePageResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
-25
View File
@@ -27,33 +27,8 @@ tags:
description: Operations related to exports
- name: AuthService
description: Operations related to authentication
- name: HealthService
description: Operations related to health
paths:
/health:
get:
operationId: isHealthy
tags:
- HealthService
summary: Provide health endpoint
description: See if the service is up and running
security:
- {}
responses:
"200":
description: Healthy service.
headers:
RateLimit:
$ref: "#/components/headers/RateLimit"
"400":
$ref: "#/components/responses/InvalidRequest"
"401":
$ref: "#/components/responses/Unauthorized"
"429":
$ref: "#/components/responses/TooManyRequests"
"500":
$ref: "#/components/responses/InternalError"
/client:
post: