Microprofile Config Sources

ConfigProviderResolver resolver = ConfigProviderResolver.instance();

Config config = resolver.getBuilder() // (1)
        .withSources(MpConfigSources.environmentVariables()) // (2)
        .withSources(MpConfigSources.create(Map.of("key", "value"))) // (3)
        .build(); // (4)

resolver.registerConfig(config, null); // (5)

ConfigProviderResolver.instance().getBuilder()
        .withSources(YamlMpConfigSource.create(path))
        .build();

public class CustomConfigSource implements ConfigSource {
    private static final String NAME = "MyConfigSource";
    private static final int ORDINAL = 200; // Default for MP is 100
    private static final Map<String, String> PROPERTIES = Map.of("app.greeting", "Hi");

    @Override
    public String getName() {
        return NAME; // (1)
    }

    @Override
    public Map<String, String> getProperties() {
        return PROPERTIES; // (2)
    }

    @Override
    public Set<String> getPropertyNames() {
        return PROPERTIES.keySet();
    }

    @Override
    public String getValue(String key) {
        return PROPERTIES.get(key); // (3)
    }

    @Override
    public int getOrdinal() {
        return ORDINAL; // (4)
    }
}

public class CustomMpMetaConfigProvider implements MpMetaConfigProvider {

    @Override
    public Set<String> supportedTypes() {
        return Set.of("custom"); // (1)
    }

    @Override
    public List<? extends ConfigSource> create(String type, io.helidon.config.Config metaConfig, String profile) {
        ConfigValue<Path> pathConfig = metaConfig.get("path").as(Path.class);
        String location;
        if (pathConfig.isPresent()) { // (2)
            Path path = pathConfig.get();
            List<ConfigSource> sources = sourceFromPath(path, profile); // (3)
            if (sources != null && !sources.isEmpty()) {
                return sources;
            }
            location = "path " + path.toAbsolutePath();
        } else {
            ConfigValue<String> classpathConfig = metaConfig.get("classpath").as(String.class);
            if (classpathConfig.isPresent()) { // (4)
                String classpath = classpathConfig.get();
                List<ConfigSource> sources = sourceFromClasspath(classpath, profile); // (5)
                if (sources != null && !sources.isEmpty()) {
                    return sources;
                }
                location = "classpath " + classpath;
            } else {
                ConfigValue<URL> urlConfig = metaConfig.get("url").as(URL.class);
                if (urlConfig.isPresent()) { // (6)
                    URL url = urlConfig.get();
                    List<ConfigSource> sources = sourceFromUrlMeta(url, profile); // (7)
                    if (sources != null && !sources.isEmpty()) {
                        return sources;
                    }
                    location = "url " + url;
                } else {
                    throw new ConfigException("No config source location for " + metaConfig.key());
                }
            }
        }
        if (metaConfig.get("optional").asBoolean().orElse(false)) {
            return List.of(); // (8)
        }
        throw new ConfigException("Meta configuration could not find non-optional config source on " + location); // (9)
    }
}