guicedee-config

MicroProfile Config implementation for GuicedEE using SmallRye Config and Guice: @ConfigProperty injection with type conversion, environment variable / system property / microprofile-config.properties sources, profile support, custom converters, programmatic SmallRyeConfig access, and JPMS setup. Use when injecting configuration values, managing config sources, adding custom converters, or using profile-specific properties.

5 stars

byGuicedEE

View on GitHub Installation ↓

Best use case

guicedee-config is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Teams using guicedee-config should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

You only need a quick one-off answer and do not need a reusable workflow.
You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/guicedee-config/SKILL.md --create-dirs "https://raw.githubusercontent.com/GuicedEE/ai-rules/main/skills/.system/guicedee-config/SKILL.md"

Manual Installation

Download SKILL.md from GitHub
Place it in .claude/skills/guicedee-config/SKILL.md inside your project
Restart your AI agent — it will auto-discover the skill

How guicedee-config Compares

Feature / Agent	guicedee-config	Standard Approach
Platform Support	Not specified	Limited / Varies
Context Awareness	High	Baseline
Installation Complexity	Unknown	N/A

Frequently Asked Questions

What does this skill do?

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# GuicedEE Config

MicroProfile Config implementation for GuicedEE using SmallRye Config and Google Guice.

## Core Concept

Inject configuration values with `@ConfigProperty`, resolve from environment variables, system properties, and `META-INF/microprofile-config.properties` — all wired automatically through SPI discovery and Guice bindings.

## Required Flow

1. Add `com.guicedee.microprofile:config` dependency.
2. Add a `microprofile-config.properties` file:
   ```properties
   # src/main/resources/META-INF/microprofile-config.properties
   messaging.enabled=true
   messaging.bootstrap.servers=localhost:9092
   liveness.port=8081
   ```
3. Inject configuration values:
   ```java
   public class MessagingService {
       @ConfigProperty(name = "messaging.enabled", defaultValue = "true")
       boolean enabled;

       @ConfigProperty(name = "messaging.bootstrap.servers")
       String bootstrapServers;
   }
   ```
4. Configure `module-info.java`:
   ```java
   module my.app {
       requires com.guicedee.microprofile.config;
       opens my.app.services to com.google.guice;
   }
   ```

## Configuration Sources

| Source | Ordinal | Example |
|---|---|---|
| Environment variables | 300 (highest) | `MESSAGING_ENABLED=true` |
| System properties | 200 | `-Dmessaging.enabled=true` |
| `META-INF/microprofile-config.properties` | 100 (lowest) | `messaging.enabled=true` |

### Key mapping
Environment variable names follow MicroProfile Config rules:
- Dots and hyphens → underscores
- Uppercased
- e.g. `messaging.bootstrap.servers` → `MESSAGING_BOOTSTRAP_SERVERS`

### Profiles
SmallRye Config supports profile-specific properties using `%profile.` prefix:

```properties
db.url=jdbc:postgresql://prod-host:5432/mydb
%dev.db.url=jdbc:postgresql://localhost:5432/mydb
```

Activate with `mp.config.profile=dev`.

## Supported Injection Types

| Type | Binding |
|---|---|
| `String` | Direct value |
| `boolean` / `Boolean` | Parsed |
| `int` / `Integer` | Parsed |
| `long` / `Long` | Parsed |
| `double` / `Double` | Parsed |
| `float` / `Float` | Parsed |
| `Optional<T>` | Wrapped optional (all above types) |

Default values via `@ConfigProperty(defaultValue = "...")`.

## Programmatic Access

```java
@Inject
SmallRyeConfig config;

int port = config.getOptionalValue("liveness.port", Integer.class).orElse(8081);
```

## Custom Converters

Register `Converter<T>` implementations via `ServiceLoader` for application-specific types.

## Startup Flow

```
IGuiceContext.instance().inject()
 └─ MicroProfileConfigContext (builds SmallRyeConfig on Vert.x worker thread)
     ├─ addDefaultSources() (env vars, system props, microprofile-config.properties)
     ├─ addDiscoveredSources() (ServiceLoader-discovered ConfigSource SPIs)
     └─ addDiscoveredConverters()
 └─ MicroProfileConfigBinder (scans @ConfigProperty fields, creates Guice bindings)
```

## Non-Negotiable Constraints

- Module must `requires com.guicedee.microprofile.config;`.
- Classes with `@ConfigProperty` fields must be in packages opened to `com.google.guice`.
- The config module is registered automatically — no `provides` needed.
- Config is built on a Vert.x worker thread to avoid blocking the event loop.

Related Skills

guicedee-websockets

from GuicedEE/ai-rules

RFC 6455 WebSocket support for GuicedEE using Vert.x 5: call-scoped connections, action-based message routing via IWebSocketMessageReceiver SPI, group management and broadcasting, WebSocketServerOptions, and lifecycle hooks. Use when adding WebSocket messaging, implementing real-time communication, managing WebSocket groups, or creating message receivers.

guicedee-webservices

from GuicedEE/ai-rules

SOAP web services for GuicedEE using Apache CXF conventions: JAX-WS annotations (@WebService, @WebMethod, @WebParam, @WebResult), code-first and WSDL-first approaches, endpoint publishing, CXF interceptors and logging, MTOM, WS-Security (WSS4J), SOAP 1.1/1.2 bindings, and Guice DI integration. Use when creating SOAP services, publishing JAX-WS endpoints, configuring CXF bindings, or adding WS-Security.

guicedee-web

from GuicedEE/ai-rules

Bootstrap reactive HTTP/HTTPS servers with Vert.x 5 inside GuicedEE: Router setup, BodyHandler configuration, TLS/HTTPS, SPI extension points (VertxRouterConfigurator, VertxHttpServerOptionsConfigurator, VertxHttpServerConfigurator), per-verticle sub-routers, and environment-driven configuration. Use when setting up the Vert.x web server, configuring HTTP/HTTPS, adding custom routes or middleware, or managing server options.

guicedee-vertx

from GuicedEE/ai-rules

Build reactive services using Vert.x 5 inside the GuicedEE DI lifecycle: event-bus consumers, publishers, verticle deployment, codecs, throttling, clustering, SPI hooks, and JPMS module setup. Use when adding Vert.x event-bus messaging, deploying verticles, wiring reactive endpoints with Guice injection, configuring Vert.x runtime options, or implementing custom codecs and cluster managers.

guicedee-service-registry

from GuicedEE/ai-rules

Named service registry with health-aware resolution for GuicedEE. Register services by simple name, auto-construct URLs from cloud DNS suffix, monitor health status, resolve services via registry:name prefix or bare name in rest-client @Endpoint. Supports aliases, multiple external URLs, Kubernetes internal URLs, and per-service health paths. Use when registering named services, checking service health, resolving service URLs by name, or integrating with rest-client for service-to-service calls.

guicedee-rest

from GuicedEE/ai-rules

Build Jakarta REST (JAX-RS) services on Vert.x 5 inside GuicedEE: @Path/@GET/@POST route registration, parameter binding (@PathParam, @QueryParam, @HeaderParam, etc.), Guice-managed resource classes, response handling, content negotiation, and JPMS module setup. Use when creating REST endpoints, configuring Jakarta REST resources, or wiring JAX-RS services with Guice injection.

guicedee-rest-client

from GuicedEE/ai-rules

Annotation-driven REST client for GuicedEE using Vert.x 5 WebClient: @Endpoint declarations, RestClient<Send, Receive> injection, authentication strategies (Bearer, Basic, API Key, OAuth2, mTLS), path parameters, environment variable overrides, package-level endpoints, service registry integration (bare name or registry: prefix), and RestClientConfigurator SPI. Use when making outbound REST calls, configuring REST client endpoints, or wiring reactive HTTP clients with Guice injection.

guicedee-rabbitmq

from GuicedEE/ai-rules

Annotation-driven RabbitMQ integration for GuicedEE with Vert.x 5: @RabbitConnectionOptions, @QueueExchange, @QueueDefinition, QueueConsumer/QueuePublisher injection, exchange management, queue options (priority, TTL, prefetch), publisher confirms, environment variable overrides, and verticle-scoped connections. Use when adding RabbitMQ messaging, declaring exchanges and queues, creating consumers and publishers, or configuring AMQP topology.

guicedee-persistence

from GuicedEE/ai-rules

Reactive JPA persistence with Hibernate Reactive 7, Vert.x 5 SQL clients, and Mutiny sessions inside GuicedEE: DatabaseModule setup, persistence.xml configuration, multi-database support, @EntityManager scoping, and environment variable resolution. Use when adding database persistence, configuring Hibernate Reactive, creating DatabaseModule subclasses, wiring Mutiny.SessionFactory, or managing multiple persistence units.

guicedee-openapi

from GuicedEE/ai-rules

Automatic OpenAPI 3.1 spec generation and serving for GuicedEE with Vert.x 5: scans Jakarta REST resources at startup, serves /openapi.json and /openapi.yaml endpoints, Swagger annotations support, @OpenAPIDefinition configuration, and companion Swagger UI module. Use when generating API documentation, serving OpenAPI specs, or configuring Swagger annotations on REST resources.

guicedee-metrics

from GuicedEE/ai-rules

Application metrics for GuicedEE using Vert.x 5 Dropwizard Metrics and MicroProfile Metrics 5.1: @Counted, @Timed, @MetricMethod annotations, Guice AOP interceptors, Prometheus scrape endpoint, Graphite reporting, JMX exposure, @MetricsOptions configuration, environment variable overrides, and Vert.x built-in metrics (event bus, HTTP, pools). Use when adding application metrics, configuring Prometheus endpoints, creating custom counters/timers, or monitoring Vert.x internals.

guicedee-mail-client

from GuicedEE/ai-rules

Annotation-driven SMTP mail client for GuicedEE with Vert.x 5: @MailConnectionOptions for SMTP server configuration, MailService injection for sending text/HTML/multipart emails with attachments, connection pooling, StartTLS/SSL support, DKIM signing, environment variable overrides, and graceful shutdown. Use when sending emails via SMTP, configuring mail connections, or injecting mail services.