DevFW-CICD/edge-connect-client
16
1
Fork 0
Code Issues Pull requests Projects Releases 15 Packages Wiki Activity Actions
65 commits 5 branches 18 tags 71 MiB
Commit graph

7 commits

Author SHA1 Message Date
Stephan Lo
488fe430fb fix(apply): fixed client logic ... responses are now filtered as before 2025-10-09 17:05:27 +02:00
Stephan Lo
5ac67a224d fix: resolve all golangci-lint errors 
- Fix errcheck errors by properly handling resp.Body.Close() return values
- Fix staticcheck ST1005 errors by uncapitalizing error messages
- Remove unused orgName variable
- Wrap all deferred Close() calls in anonymous functions to handle errors
 2025-10-09 10:54:14 +02:00
Stephan Lo
1c13c93512 refactor(arch): Relocate domain and ports packages 
Moves the `domain` and `ports` packages from `internal/core` to `internal`.

This refactoring simplifies the directory structure by elevating the core architectural concepts of domain and ports to the top level of the `internal` directory. The `core` directory is now removed as its only purpose was to house these two packages.

All import paths across the project have been updated to reflect this change.
 2025-10-09 01:16:31 +02:00
Stephan Lo
8d6f51978d feat(organization): WiP - Add organization management 
Adds the core functionality for managing organizations, including the domain, application service, repository, and CLI adapter.

The `organization` command and its subcommands (`create`, `show`, `update`, `delete`) are now available.

Note: The `show` command is currently not working as expected due to an API issue where it does not find the newly created organization. This is marked as a work in progress.
 2025-10-09 01:01:56 +02:00
Stephan Lo
7b062612f5 refactor(arch): Separate infrastructure from driven adapter 
This commit introduces a significant architectural refactoring to decouple the driven adapter from low-level infrastructure concerns, adhering more strictly to the principles of Hexagonal Architecture.

Problem:
The driven adapter in `internal/adapters/driven/edgeconnect` was responsible for both adapting data structures and handling direct HTTP communication, authentication, and request/response logic. This violated the separation of concerns, making the adapter difficult to test and maintain.

Solution:
A new infrastructure layer has been created at `internal/infrastructure`. This layer now contains all the low-level details of interacting with the EdgeConnect API.

Key Changes:
- **New Infrastructure Layer:** Created `internal/infrastructure` to house components that connect to external systems.
- **Generic HTTP Client:** A new, generic `edgeconnect_client` was created in `internal/infrastructure/edgeconnect_client`. It is responsible for authentication, making HTTP requests, and handling raw responses. It has no knowledge of the application's domain models.
- **Config & Transport Moved:** The `config` and `http` (now `transport`) packages were moved into the infrastructure layer, as they are details of how the application is configured and communicates.
- **Consolidated Driven Adapter:** The logic from the numerous old adapter files (`apps.go`, `cloudlet.go`, etc.) has been consolidated into a single, true adapter at `internal/adapters/driven/edgeconnect/adapter.go`.
- **Clear Responsibility:** The new `adapter.go` is now solely responsible for:
  1. Implementing the driven port (repository) interfaces.
  2. Translating domain models into the data structures required by the `edgeconnect_client`.
  3. Calling the `edgeconnect_client` to perform the API operations.
  4. Translating the results back into domain models.
- **Updated Dependency Injection:** The application's entry point (`cmd/cli/main.go`) has been updated to construct and inject dependencies according to the new architecture: `infra_client` -> `adapter` -> `service` -> `cli_command`.
- **SDK & Apply Command:** The SDK examples and the `apply` command have been updated to use the new adapter and its repository methods, removing all direct client instantiation.
 2025-10-09 00:47:45 +02:00
Stephan Lo
19a9807499 fix: resolve all 27 golangci-lint issues with comprehensive error handling 
🔧 Code Quality Improvements:
- Complete errcheck compliance (24 issues → 0)
- staticcheck optimizations (2 issues → 0)
- Unused code cleanup (1 issue → 0)
- Production-ready error handling across codebase

📦 Production Code Fixes (Priority 1):
- resp.Body.Close(): Proper defer functions with error logging
- cmd.MarkFlagRequired(): Panic on setup-critical flag errors
- viper.BindPFlag/BindEnv(): Panic on configuration binding failures
- file.Close(): Warning logs for file handling errors
- fmt.Scanln/cmd.Usage(): Graceful error handling in CLI

🧪 Test Code Fixes (Priority 2):
- w.Write(): Error checking in all HTTP mock servers
- json.NewEncoder().Encode(): Proper error handling in test helpers
- Robust test infrastructure without silent failures

⚡ Performance & Readability (staticcheck):
- if-else chains → tagged switch statements in planner.go
- Empty branch elimination with meaningful error logging
- Import cleanup after unused function removal

🗂️ Code Organization:
- Removed unused createStreamingJSONServer helper function
- Clean imports without unused dependencies
- Consistent error handling patterns across adapters

✅ Quality Assurance:
- make lint: 27 issues → 0 issues
- All tests passing with robust error handling
- Production-ready error management and logging
- Enhanced code maintainability and debugging

🎯 Impact:
- Eliminates resource leaks from unclosed HTTP bodies
- Prevents silent failures in CLI setup and configuration
- Improves debugging with comprehensive error logging
- Enhances test reliability and error visibility
 2025-10-08 18:55:31 +02:00
Stephan Lo
8e2e61d61e feat: implement dependency injection with proper hexagonal architecture 
✨ Features:
- Simple dependency inversion following SOLID principles
- Clean constructor injection without complex DI containers
- Proper hexagonal architecture with driving/driven separation
- Presentation layer moved to cmd/cli for correct application structure

🏗️ Architecture Changes:
- Driving Adapters (Inbound): internal/adapters/driving/cli/
- Driven Adapters (Outbound): internal/adapters/driven/edgeconnect/
- Core Services: Dependency-injected via interface parameters
- main.go relocated from root to cmd/cli/main.go

📦 Application Flow:
1. cmd/cli/main.go - Entry point and dependency wiring
   └── Creates EdgeConnect client based on environment
   └── Instantiates services with injected repositories
   └── Executes CLI with properly wired dependencies

2. internal/adapters/driving/cli/ - User interface layer
   └── Receives user commands and input validation
   └── Delegates to core services via driving ports
   └── Handles presentation logic and output formatting

3. internal/core/services/ - Business logic layer
   └── NewAppService(appRepo, instanceRepo) - Constructor injection
   └── NewAppInstanceService(instanceRepo) - Interface dependencies
   └── NewCloudletService(cloudletRepo) - Clean separation

4. internal/adapters/driven/edgeconnect/ - Infrastructure layer
   └── Implements repository interfaces for external API
   └── Handles HTTP communication and data persistence
   └── Provides concrete implementations of driven ports

🔧 Build & Deployment:
- CLI Binary: make build → bin/edge-connect-cli
- Usage: ./bin/edge-connect-cli --help
- Tests: make test (all passing)
- Clean: make clean (updated paths)

💡 Benefits:
- Simple and maintainable dependency management
- Testable architecture with clear boundaries
- SOLID principles compliance without overengineering
- Proper separation of concerns in hexagonal structure
 2025-10-08 18:15:26 +02:00