@decohere/config 0.0.1-dev.116

package/commonjs/src/configuration-data-source.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ConfigurationDataSource", {
+    enumerable: true,
+    get: function() {
+        return ConfigurationDataSource;
+    }
+});
+class ConfigurationDataSource {
+}

package/commonjs/src/configuration.extensions.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BuilderExtensions", {
+    enumerable: true,
+    get: function() {
+        return BuilderExtensions;
+    }
+});
+const _http = require("@decohere/http");
+const _configuration = require("@decohere/core/configuration");
+const _extensibility = require("@decohere/core/extensibility");
+const _configurationservice = require("./configuration.service.js");
+const _const = require("./const.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class BuilderExtensions {
+    static withConfiguration(builder, ...dataSourceArgs) {
+        const dataSources = dataSourceArgs ?? [];
+        builder.withServices((builder)=>{
+            builder.registerSingleton(_configuration.ConfigurationServiceToken, _configurationservice.ConfigurationService);
+            for (const dataSource of dataSources){
+                builder.registerSingleton(_const.ConfigurationDataSourceKey, dataSource);
+            }
+        });
+        return builder;
+    }
+}
+_ts_decorate([
+    (0, _extensibility.extension)(_http.Builder),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _http.Builder === "undefined" ? Object : _http.Builder,
+        Array
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], BuilderExtensions, "withConfiguration", null);

package/commonjs/src/configuration.service.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ConfigurationService", {
+    enumerable: true,
+    get: function() {
+        return ConfigurationService;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _caching = require("@decohere/core/caching");
+const _system = require("@decohere/core/system");
+const _const = require("./const.js");
+const _errors = require("./errors.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+class ConfigurationService {
+    data = {};
+    dataSources = [];
+    isInitialized = false;
+    constructor(dataSources = []){
+        this.dataSources = dataSources;
+    }
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        const records = await Promise.all(this.dataSources.map(async (d)=>await d.getData()));
+        this.validateDataSources(records);
+        const entries = records.flatMap((r)=>Object.entries(r));
+        this.data = Object.fromEntries(entries);
+        this.isInitialized = true;
+    }
+    async get(typeOrString) {
+        await this.ensureInitialized();
+        const obj = typeof typeOrString === "string" ? this.getStringKey(typeOrString) : this.getConstructable(typeOrString);
+        return obj;
+    }
+    async ensureInitialized() {
+        if (this.isInitialized) return;
+        await this.initialize();
+    }
+    validateDataSources(records) {
+        const keys = records.flatMap((record)=>Object.keys(record));
+        const uniqueKeys = new Set(keys);
+        if (uniqueKeys.size < keys.length) {
+            throw new _errors.ConfigurationError(`Cannot have duplicate data source names. The data sources are: ${keys.join(",")}`);
+        }
+    }
+    getConstructable(type) {
+        const key = (0, _system.lowerCamelCase)(type?.name.replace(/configuration|config/i, ""));
+        const data = this.data[key];
+        const configObject = new type();
+        Object.assign(configObject, data);
+        return configObject;
+    }
+    getStringKey(key) {
+        const data = this.data[key];
+        return data;
+    }
+}
+_ts_decorate([
+    (0, _caching.memoize)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Constructable === "undefined" ? Object : Constructable
+    ]),
+    _ts_metadata("design:returntype", typeof T === "undefined" ? Object : T)
+], ConfigurationService.prototype, "getConstructable", null);
+_ts_decorate([
+    (0, _caching.cache)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", typeof T === "undefined" ? Object : T)
+], ConfigurationService.prototype, "getStringKey", null);
+ConfigurationService = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_param(0, (0, _decorators.inject)(_const.ConfigurationDataSourceKey)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array
+    ])
+], ConfigurationService);

package/commonjs/src/const.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ConfigurationDataSourceKey () {
+        return ConfigurationDataSourceKey;
+    },
+    get DEFAULT_CONFIG_DIR () {
+        return DEFAULT_CONFIG_DIR;
+    }
+});
+const ConfigurationDataSourceKey = Symbol("ConfigurationDataSourceKey");
+const DEFAULT_CONFIG_DIR = "config";

package/commonjs/src/errors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ConfigurationError", {
+    enumerable: true,
+    get: function() {
+        return ConfigurationError;
+    }
+});
+class ConfigurationError extends Error {
+}

package/commonjs/src/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./configuration.extensions.js"), exports);
+_export_star(require("./configuration.service.js"), exports);
+_export_star(require("./configuration-data-source.js"), exports);
+_export_star(require("./const.js"), exports);
+_export_star(require("./yaml-data-source.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/commonjs/src/yaml-data-source.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get YamlDataSource () {
+        return YamlDataSource;
+    },
+    get resolveConfigEnv () {
+        return resolveConfigEnv;
+    },
+    get resolveYamlConfig () {
+        return resolveYamlConfig;
+    }
+});
+const _io = require("@decohere/core/io");
+const _yaml = require("yaml");
+const _configurationdatasource = require("./configuration-data-source.js");
+const _const = require("./const.js");
+const _errors = require("./errors.js");
+const CONFIG_FILE_NAME = "config";
+/** Unset NODE_ENV must not silently load config.dev.yaml (TypeORM synchronize, etc.). */ const DEFAULT_ENV = "production";
+const FILE_EXT = "yaml";
+function resolveConfigEnv(nodeEnv) {
+    const env = nodeEnv ?? process.env.NODE_ENV;
+    if (env == null || env.trim() === "") {
+        return DEFAULT_ENV;
+    }
+    return env;
+}
+/** `${NAME}` or `${NAME:default}`. The default may be empty, and runs up to the first `}`. */ const PLACEHOLDER = /\$\{(\w+)(?::([^}]*))?\}/g;
+function isTree(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+/** Objects merge key by key; a list or a scalar in the later file replaces the earlier value. */ function merge(base, override) {
+    const merged = {
+        ...base
+    };
+    for (const [key, value] of Object.entries(override)){
+        const existing = merged[key];
+        merged[key] = isTree(existing) && isTree(value) ? merge(existing, value) : value;
+    }
+    return merged;
+}
+function resolveString(value, path, missing) {
+    let hasPlaceholder = false;
+    const resolved = value.replace(PLACEHOLDER, (_match, name, fallback)=>{
+        hasPlaceholder = true;
+        const fromEnv = process.env[name];
+        if (fromEnv !== undefined) {
+            return fromEnv;
+        }
+        if (fallback !== undefined) {
+            return fallback;
+        }
+        missing.push({
+            name,
+            path
+        });
+        return "";
+    });
+    // A variable set to the text "null" means no value.
+    return hasPlaceholder && resolved === "null" ? null : resolved;
+}
+function resolveValue(value, path, missing) {
+    if (typeof value === "string") {
+        return resolveString(value, path, missing);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index)=>resolveValue(item, `${path}[${index}]`, missing));
+    }
+    if (isTree(value)) {
+        const resolved = {};
+        for (const [key, item] of Object.entries(value)){
+            resolved[key] = resolveValue(item, path === "" ? key : `${path}.${key}`, missing);
+        }
+        return resolved;
+    }
+    return value;
+}
+function parseSource({ name, text }) {
+    let parsed;
+    try {
+        parsed = (0, _yaml.parse)(text);
+    } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new _errors.ConfigurationError(`Cannot parse config file ${name}: ${reason}`);
+    }
+    if (parsed == null) {
+        return undefined;
+    }
+    if (!isTree(parsed)) {
+        throw new _errors.ConfigurationError(`Config file ${name} must contain a mapping at the top level`);
+    }
+    return parsed;
+}
+function resolveYamlConfig(sources) {
+    let merged = {};
+    for (const source of sources){
+        const tree = parseSource(source);
+        if (tree !== undefined) {
+            merged = merge(merged, tree);
+        }
+    }
+    const missing = [];
+    const resolved = resolveValue(merged, "", missing);
+    if (missing.length > 0) {
+        const lines = missing.map(({ name, path })=>`  - ${name} (used at ${path})`);
+        throw new _errors.ConfigurationError(`Config references ${missing.length} environment variable(s) that are not set:\n${lines.join("\n")}\n` + "Set them, give the value a default with ${NAME:default}, or replace it in the environment's config file.");
+    }
+    return resolved;
+}
+class YamlDataSource extends _configurationdatasource.ConfigurationDataSource {
+    name = YamlDataSource.name;
+    async getData() {
+        const configDir = process.env.CONFIG_DIR ?? _const.DEFAULT_CONFIG_DIR;
+        const env = resolveConfigEnv();
+        const candidates = [
+            `${configDir}/${CONFIG_FILE_NAME}.${FILE_EXT}`,
+            `${configDir}/${CONFIG_FILE_NAME}.${env}.${FILE_EXT}`
+        ];
+        const sources = [];
+        for (const filePath of candidates){
+            if (await _io.io.fileExists(filePath)) {
+                sources.push({
+                    name: filePath,
+                    text: await _io.io.readFile(filePath)
+                });
+            }
+        }
+        return resolveYamlConfig(sources);
+    }
+}

package/es6/src/configuration-data-source.js

@@ -0,0 +1,2 @@
+export class ConfigurationDataSource {
+}

package/es6/src/configuration.extensions.js

@@ -0,0 +1,35 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { Builder } from "@decohere/http";
+import { ConfigurationServiceToken } from "@decohere/core/configuration";
+import { extension } from "@decohere/core/extensibility";
+import { ConfigurationService } from "./configuration.service.js";
+import { ConfigurationDataSourceKey } from "./const.js";
+export class BuilderExtensions {
+    static withConfiguration(builder, ...dataSourceArgs) {
+        const dataSources = dataSourceArgs ?? [];
+        builder.withServices((builder)=>{
+            builder.registerSingleton(ConfigurationServiceToken, ConfigurationService);
+            for (const dataSource of dataSources){
+                builder.registerSingleton(ConfigurationDataSourceKey, dataSource);
+            }
+        });
+        return builder;
+    }
+}
+_ts_decorate([
+    extension(Builder),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Builder === "undefined" ? Object : Builder,
+        Array
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], BuilderExtensions, "withConfiguration", null);

package/es6/src/configuration.service.js

@@ -0,0 +1,88 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { inject, injectable } from "@decohere/crucible/decorators";
+import { cache, memoize } from "@decohere/core/caching";
+import { lowerCamelCase } from "@decohere/core/system";
+import { ConfigurationDataSourceKey } from "./const.js";
+import { ConfigurationError } from "./errors.js";
+export class ConfigurationService {
+    data = {};
+    dataSources = [];
+    isInitialized = false;
+    constructor(dataSources = []){
+        this.dataSources = dataSources;
+    }
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        const records = await Promise.all(this.dataSources.map(async (d)=>await d.getData()));
+        this.validateDataSources(records);
+        const entries = records.flatMap((r)=>Object.entries(r));
+        this.data = Object.fromEntries(entries);
+        this.isInitialized = true;
+    }
+    async get(typeOrString) {
+        await this.ensureInitialized();
+        const obj = typeof typeOrString === "string" ? this.getStringKey(typeOrString) : this.getConstructable(typeOrString);
+        return obj;
+    }
+    async ensureInitialized() {
+        if (this.isInitialized) return;
+        await this.initialize();
+    }
+    validateDataSources(records) {
+        const keys = records.flatMap((record)=>Object.keys(record));
+        const uniqueKeys = new Set(keys);
+        if (uniqueKeys.size < keys.length) {
+            throw new ConfigurationError(`Cannot have duplicate data source names. The data sources are: ${keys.join(",")}`);
+        }
+    }
+    getConstructable(type) {
+        const key = lowerCamelCase(type?.name.replace(/configuration|config/i, ""));
+        const data = this.data[key];
+        const configObject = new type();
+        Object.assign(configObject, data);
+        return configObject;
+    }
+    getStringKey(key) {
+        const data = this.data[key];
+        return data;
+    }
+}
+_ts_decorate([
+    memoize(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Constructable === "undefined" ? Object : Constructable
+    ]),
+    _ts_metadata("design:returntype", typeof T === "undefined" ? Object : T)
+], ConfigurationService.prototype, "getConstructable", null);
+_ts_decorate([
+    cache(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", typeof T === "undefined" ? Object : T)
+], ConfigurationService.prototype, "getStringKey", null);
+ConfigurationService = _ts_decorate([
+    injectable(),
+    _ts_param(0, inject(ConfigurationDataSourceKey)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array
+    ])
+], ConfigurationService);

package/es6/src/const.js

@@ -0,0 +1,2 @@
+export const ConfigurationDataSourceKey = Symbol("ConfigurationDataSourceKey");
+export const DEFAULT_CONFIG_DIR = "config";

package/es6/src/errors.js

@@ -0,0 +1,2 @@
+export class ConfigurationError extends Error {
+}

package/es6/src/index.js

@@ -0,0 +1,5 @@
+export * from "./configuration.extensions.js";
+export * from "./configuration.service.js";
+export * from "./configuration-data-source.js";
+export * from "./const.js";
+export * from "./yaml-data-source.js";

package/es6/src/yaml-data-source.js

@@ -0,0 +1,126 @@
+import { io } from "@decohere/core/io";
+import { parse } from "yaml";
+import { ConfigurationDataSource } from "./configuration-data-source.js";
+import { DEFAULT_CONFIG_DIR } from "./const.js";
+import { ConfigurationError } from "./errors.js";
+const CONFIG_FILE_NAME = "config";
+/** Unset NODE_ENV must not silently load config.dev.yaml (TypeORM synchronize, etc.). */ const DEFAULT_ENV = "production";
+const FILE_EXT = "yaml";
+/** Resolve which env-specific config file to merge (e.g. config.dev.yaml). */ export function resolveConfigEnv(nodeEnv) {
+    const env = nodeEnv ?? process.env.NODE_ENV;
+    if (env == null || env.trim() === "") {
+        return DEFAULT_ENV;
+    }
+    return env;
+}
+/** `${NAME}` or `${NAME:default}`. The default may be empty, and runs up to the first `}`. */ const PLACEHOLDER = /\$\{(\w+)(?::([^}]*))?\}/g;
+function isTree(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+/** Objects merge key by key; a list or a scalar in the later file replaces the earlier value. */ function merge(base, override) {
+    const merged = {
+        ...base
+    };
+    for (const [key, value] of Object.entries(override)){
+        const existing = merged[key];
+        merged[key] = isTree(existing) && isTree(value) ? merge(existing, value) : value;
+    }
+    return merged;
+}
+function resolveString(value, path, missing) {
+    let hasPlaceholder = false;
+    const resolved = value.replace(PLACEHOLDER, (_match, name, fallback)=>{
+        hasPlaceholder = true;
+        const fromEnv = process.env[name];
+        if (fromEnv !== undefined) {
+            return fromEnv;
+        }
+        if (fallback !== undefined) {
+            return fallback;
+        }
+        missing.push({
+            name,
+            path
+        });
+        return "";
+    });
+    // A variable set to the text "null" means no value.
+    return hasPlaceholder && resolved === "null" ? null : resolved;
+}
+function resolveValue(value, path, missing) {
+    if (typeof value === "string") {
+        return resolveString(value, path, missing);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index)=>resolveValue(item, `${path}[${index}]`, missing));
+    }
+    if (isTree(value)) {
+        const resolved = {};
+        for (const [key, item] of Object.entries(value)){
+            resolved[key] = resolveValue(item, path === "" ? key : `${path}.${key}`, missing);
+        }
+        return resolved;
+    }
+    return value;
+}
+function parseSource({ name, text }) {
+    let parsed;
+    try {
+        parsed = parse(text);
+    } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new ConfigurationError(`Cannot parse config file ${name}: ${reason}`);
+    }
+    if (parsed == null) {
+        return undefined;
+    }
+    if (!isTree(parsed)) {
+        throw new ConfigurationError(`Config file ${name} must contain a mapping at the top level`);
+    }
+    return parsed;
+}
+/**
+ * Merge config files in order (later files win), then resolve `${VAR}` placeholders on the
+ * merged result.
+ *
+ * Resolving after the merge means an environment file such as `config.dev.yaml` can replace a
+ * production `${VAR}` without that variable being set: a placeholder that was replaced is never
+ * looked up. Placeholders still unset after the merge fail together, naming every variable and
+ * the config path that used it. `${VAR:default}` keeps a default for optional values.
+ */ export function resolveYamlConfig(sources) {
+    let merged = {};
+    for (const source of sources){
+        const tree = parseSource(source);
+        if (tree !== undefined) {
+            merged = merge(merged, tree);
+        }
+    }
+    const missing = [];
+    const resolved = resolveValue(merged, "", missing);
+    if (missing.length > 0) {
+        const lines = missing.map(({ name, path })=>`  - ${name} (used at ${path})`);
+        throw new ConfigurationError(`Config references ${missing.length} environment variable(s) that are not set:\n${lines.join("\n")}\n` + "Set them, give the value a default with ${NAME:default}, or replace it in the environment's config file.");
+    }
+    return resolved;
+}
+export class YamlDataSource extends ConfigurationDataSource {
+    name = YamlDataSource.name;
+    async getData() {
+        const configDir = process.env.CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
+        const env = resolveConfigEnv();
+        const candidates = [
+            `${configDir}/${CONFIG_FILE_NAME}.${FILE_EXT}`,
+            `${configDir}/${CONFIG_FILE_NAME}.${env}.${FILE_EXT}`
+        ];
+        const sources = [];
+        for (const filePath of candidates){
+            if (await io.fileExists(filePath)) {
+                sources.push({
+                    name: filePath,
+                    text: await io.readFile(filePath)
+                });
+            }
+        }
+        return resolveYamlConfig(sources);
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@decohere/config",
+  "version": "0.0.1-dev.116",
+  "description": "Database ORM abstractions and repository patterns built on TypeORM",
+  "keywords": [
+    "typescript",
+    "typeorm",
+    "orm",
+    "database",
+    "repository",
+    "decohere"
+  ],
+  "license": "ISC",
+  "author": "Typesmiths",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "types": "./types/src/index.d.ts",
+      "import": "./es6/src/index.js",
+      "require": "./commonjs/src/index.js"
+    }
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@decohere/core": "0.0.1-dev.116",
+    "@decohere/crucible": "0.0.1-dev.116",
+    "@decohere/http": "0.0.1-dev.116",
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {}
+}

package/types/src/configuration-data-source.d.ts

@@ -0,0 +1,8 @@
+export interface IConfigurationDataSource {
+    readonly name: string;
+    getData(): Promise<Record<string, unknown>>;
+}
+export declare abstract class ConfigurationDataSource implements IConfigurationDataSource {
+    abstract readonly name: string;
+    abstract getData(): Promise<Record<string, unknown>>;
+}

package/types/src/configuration.extensions.d.ts

@@ -0,0 +1,16 @@
+import { Builder } from "@decohere/http";
+import { type IConfigurationService } from "@decohere/core/configuration";
+import type { Constructable } from "@decohere/core/reflection";
+import type { ConfigurationDataSource } from "./configuration-data-source.js";
+export type ConfigurationOptions = {
+    configurationService?: Constructable<IConfigurationService>;
+    dataSources?: Constructable<ConfigurationDataSource>[];
+};
+declare module "@decohere/http" {
+    interface Builder {
+        withConfiguration(...dataSources: Constructable<ConfigurationDataSource>[]): Builder;
+    }
+}
+export declare class BuilderExtensions {
+    static withConfiguration(builder: Builder, ...dataSourceArgs: Constructable<ConfigurationDataSource>[]): Builder<import("@decohere/http").App>;
+}

package/types/src/configuration.service.d.ts

@@ -0,0 +1,15 @@
+import type { IConfigurationService } from "@decohere/core/configuration";
+import type { Constructable } from "@decohere/core/reflection";
+import type { ConfigurationDataSource } from "./configuration-data-source.js";
+export declare class ConfigurationService implements IConfigurationService {
+    protected data: Record<string, unknown>;
+    readonly dataSources: readonly ConfigurationDataSource[];
+    protected isInitialized: boolean;
+    constructor(dataSources?: ConfigurationDataSource[]);
+    private initialize;
+    get<T extends object>(typeOrString: Constructable<T> | string): Promise<T>;
+    private ensureInitialized;
+    private validateDataSources;
+    private getConstructable;
+    private getStringKey;
+}

package/types/src/const.d.ts

@@ -0,0 +1,2 @@
+export declare const ConfigurationDataSourceKey: unique symbol;
+export declare const DEFAULT_CONFIG_DIR = "config";

package/types/src/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class ConfigurationError extends Error {
+}

package/types/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./configuration.extensions.js";
+export * from "./configuration.service.js";
+export * from "./configuration-data-source.js";
+export * from "./const.js";
+export * from "./yaml-data-source.js";

package/types/src/yaml-data-source.d.ts

@@ -0,0 +1,24 @@
+import { ConfigurationDataSource } from "./configuration-data-source.js";
+/** Resolve which env-specific config file to merge (e.g. config.dev.yaml). */
+export declare function resolveConfigEnv(nodeEnv?: string): string;
+export type ConfigSource = {
+    /** Shown in errors, e.g. the file name. */
+    name: string;
+    text: string;
+};
+type Tree = Record<string, unknown>;
+/**
+ * Merge config files in order (later files win), then resolve `${VAR}` placeholders on the
+ * merged result.
+ *
+ * Resolving after the merge means an environment file such as `config.dev.yaml` can replace a
+ * production `${VAR}` without that variable being set: a placeholder that was replaced is never
+ * looked up. Placeholders still unset after the merge fail together, naming every variable and
+ * the config path that used it. `${VAR:default}` keeps a default for optional values.
+ */
+export declare function resolveYamlConfig(sources: ConfigSource[]): Tree;
+export declare class YamlDataSource extends ConfigurationDataSource {
+    name: string;
+    getData(): Promise<Record<string, unknown>>;
+}
+export {};