@decohere/config 0.0.1-dev.125 → 0.0.1-dev.5

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

@@ -1,172 +0,0 @@
-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);
-}
-/** A non-empty list whose every entry is a mapping with a string `name`, such as `dataSources`. */ function isNamedList(value) {
-    return Array.isArray(value) && value.length > 0 && value.every((item)=>isTree(item) && typeof item.name === "string");
-}
-/** Entries with the same name merge in place; new names are added at the end. */ function mergeNamedLists(base, override) {
-    const merged = [
-        ...base
-    ];
-    for (const entry of override){
-        const index = merged.findIndex((item)=>item.name === entry.name);
-        if (index === -1) {
-            merged.push(entry);
-        } else {
-            merged[index] = merge(merged[index], entry);
-        }
-    }
-    return merged;
-}
-/**
- * Objects merge key by key, and so do lists of named entries (matched by `name`), so an
- * environment file only states what it changes. Any other list, and 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];
-        if (isTree(existing) && isTree(value)) {
-            merged[key] = merge(existing, value);
-        } else if (isNamedList(existing) && isNamedList(value)) {
-            merged[key] = mergeNamedLists(existing, value);
-        } else {
-            merged[key] = value;
-        }
-    }
-    return merged;
-}
-/** A named list that repeats a name can't be merged by name, so say which file and where. */ function assertUniqueNames(value, source, path) {
-    if (isNamedList(value)) {
-        const seen = new Set();
-        for (const item of value){
-            if (seen.has(item.name)) {
-                throw new ConfigurationError(`Config file ${source}: ${path} lists the name "${String(item.name)}" more than once`);
-            }
-            seen.add(item.name);
-        }
-    }
-    if (Array.isArray(value)) {
-        value.forEach((item, index)=>assertUniqueNames(item, source, `${path}[${index}]`));
-    } else if (isTree(value)) {
-        for (const [key, item] of Object.entries(value)){
-            assertUniqueNames(item, source, path === "" ? key : `${path}.${key}`);
-        }
-    }
-}
-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`);
-    }
-    assertUniqueNames(parsed, name, "");
-    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/types/src/configuration-data-source.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

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

package/types/src/errors.d.ts

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

package/types/src/index.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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 {};