diff --git a/CLAUDE.MD b/CLAUDE.MD new file mode 100644 index 00000000..549220cd --- /dev/null +++ b/CLAUDE.MD @@ -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 +Don’t 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**: `API` format +- **Runner naming**: `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//runner.go` implementing `Controller` interface +2. Create `cmd//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 diff --git a/api/queryAPI/api.gen.go b/api/queryAPI/api.gen.go index 4c581ecb..40d326f2 100644 --- a/api/queryAPI/api.gen.go +++ b/api/queryAPI/api.gen.go @@ -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 diff --git a/api/queryAPI/health.go b/api/queryAPI/health.go deleted file mode 100644 index e105f635..00000000 --- a/api/queryAPI/health.go +++ /dev/null @@ -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) -} diff --git a/api/queryAPI/health_test.go b/api/queryAPI/health_test.go deleted file mode 100644 index 35cc6464..00000000 --- a/api/queryAPI/health_test.go +++ /dev/null @@ -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) -} diff --git a/devbox.lock b/devbox.lock index d7874f2f..62566319 100644 --- a/devbox.lock +++ b/devbox.lock @@ -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", diff --git a/internal/server/api/listener.go b/internal/server/api/listener.go index 0eca1ab6..613afaa3 100644 --- a/internal/server/api/listener.go +++ b/internal/server/api/listener.go @@ -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, diff --git a/internal/server/api/listener_test.go b/internal/server/api/listener_test.go index 6350442c..69151226 100644 --- a/internal/server/api/listener_test.go +++ b/internal/server/api/listener_test.go @@ -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, diff --git a/mocks/queryapi/mock_ClientInterface.go b/mocks/queryapi/mock_ClientInterface.go index 1dc4c78a..b91d0427 100644 --- a/mocks/queryapi/mock_ClientInterface.go +++ b/mocks/queryapi/mock_ClientInterface.go @@ -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)) diff --git a/mocks/queryapi/mock_ClientWithResponsesInterface.go b/mocks/queryapi/mock_ClientWithResponsesInterface.go index 85ccec41..83ace41e 100644 --- a/mocks/queryapi/mock_ClientWithResponsesInterface.go +++ b/mocks/queryapi/mock_ClientWithResponsesInterface.go @@ -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)) diff --git a/pkg/queryAPI/api.gen.go b/pkg/queryAPI/api.gen.go index 7b266cb4..0a7d999e 100644 --- a/pkg/queryAPI/api.gen.go +++ b/pkg/queryAPI/api.gen.go @@ -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) diff --git a/serviceAPIs/queryAPI.yaml b/serviceAPIs/queryAPI.yaml index 28717d7b..60d95d34 100644 --- a/serviceAPIs/queryAPI.yaml +++ b/serviceAPIs/queryAPI.yaml @@ -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: