@wcaservices/config 1.1.0 → 1.1.1

package/dist/index.cjs

@@ -0,0 +1,86 @@
+let _wcaservices_util_lib = require("@wcaservices/util/lib");
+
+//#region src/environment/Errors.ts
+var EnvironmentVariableError = class extends Error {};
+var RequiredEnvironmentVariableError = class extends EnvironmentVariableError {
+	constructor(config) {
+		super(`Required environment variable "${config.name}" is missing. Make sure one is set before starting the process!`);
+		this.config = config;
+	}
+};
+
+//#endregion
+//#region src/environment/EnvironmentVariables.ts
+var EnvironmentVariables = class {
+	constructor(variables) {
+		this.variables = variables;
+		return new Proxy(this, {
+			get(target, prop, receiver) {
+				if (prop in target) return Reflect.get(target, prop, receiver);
+				return target.getVariable(prop);
+			},
+			set(target, prop, value, receiver) {
+				return target.setVariable(prop, value);
+			}
+		});
+	}
+	validate() {
+		this.validateRequiredVariables();
+	}
+	validateRequiredVariables() {
+		Object.entries(this.variables).forEach(([key, config]) => {
+			if (!config.required) return;
+			if (typeof this.getVariable(key) === "undefined") throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));
+		});
+	}
+	getVariable(key) {
+		const config = this.variables[key];
+		if (!config) throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);
+		const originalValue = process.env[key] ?? config.default;
+		let value = originalValue;
+		const cast = config.type ?? "default";
+		if (config.required && typeof value === "undefined") throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));
+		switch (cast) {
+			case "BOOLEAN":
+				value = (0, _wcaservices_util_lib.envFlag)(key);
+				break;
+			case "NUMBER":
+				value = Number(value);
+				if (Number.isNaN(value)) throw new EnvironmentVariableError(`Invalid number type for '${key}': ${originalValue}`);
+				break;
+			case "JSON":
+				JSON.parse(String(value));
+				break;
+		}
+		if (config.transform) value = config.transform(value);
+		return value;
+	}
+	setVariable(key, value) {
+		const config = this.variables[key];
+		if (!config) throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);
+		if (config.transform) throw new EnvironmentVariableError("Setting environment variables with transform functions is not yet supported.");
+		switch (config.type) {
+			case "BOOLEAN":
+			case "NUMBER":
+			case "default":
+				process.env[key] = String(value);
+				return true;
+			case "JSON":
+				process.env[key] = JSON.stringify(value);
+				return true;
+		}
+		throw new EnvironmentVariableError(`Invalid type '${config.type}' for environment variable '${key}'`);
+	}
+};
+
+//#endregion
+//#region src/environment/defineEnvironmentVariables.ts
+function defineEnvironmentVariables(variables) {
+	const instance = new EnvironmentVariables(variables);
+	instance.validate();
+	return instance;
+}
+
+//#endregion
+exports.defineEnvironmentVariables = defineEnvironmentVariables;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/environment/Errors.ts","../src/environment/EnvironmentVariables.ts","../src/environment/defineEnvironmentVariables.ts"],"sourcesContent":["import type { EnvironmentVariableConfig } from './Types.ts';\n\nexport class EnvironmentVariableError extends Error {\n}\n\nexport class RequiredEnvironmentVariableError extends EnvironmentVariableError {\n    constructor(public readonly config: EnvironmentVariableConfig & { name: string }) {\n        super(`Required environment variable \"${config.name}\" is missing. Make sure one is set before starting the process!`);\n    }\n}","import { envFlag } from '@wcaservices/util/lib';\nimport { EnvironmentVariableError, RequiredEnvironmentVariableError } from './Errors.ts';\nimport type { VariableDefinitionMap, VariableOutputType } from './Types.ts';\n\nexport class EnvironmentVariables<TVariables extends VariableDefinitionMap> {\n    constructor(protected readonly variables: TVariables) {\n        return new Proxy(this, {\n            get(target, prop, receiver) {\n                if (prop in target) {\n                    return Reflect.get(target, prop, receiver);\n                }\n                return target.getVariable(prop as string);\n            },\n            set(target, prop, value, receiver) {\n                return target.setVariable(prop as string, value);\n            }\n        })\n    }\n    \n    public validate(): void {\n        this.validateRequiredVariables();\n    }\n    \n    protected validateRequiredVariables(): void {\n        Object.entries(this.variables).forEach(([key, config]) => {\n            if (!config.required) {\n                return;\n            }\n            \n            const value = this.getVariable(key);\n            \n            if (typeof value === 'undefined') {\n                throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));\n            }\n        })\n    }\n    \n    protected getVariable(key: string): unknown {\n        const config = this.variables[key];\n        \n        if (!config) {\n            throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);\n        }\n        \n        const originalValue = process.env[key] ?? config.default;\n        let value: unknown = originalValue;\n        const cast = config.type ?? 'default';\n        \n        if (config.required && typeof value === 'undefined') {\n            throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));\n        }\n        \n        switch (cast) {\n            case 'BOOLEAN':\n                value = envFlag(key);\n                break;\n            case 'NUMBER':\n                value = Number(value);\n                if (Number.isNaN(value)) {\n                    throw new EnvironmentVariableError(`Invalid number type for '${key}': ${originalValue}`);\n                }\n                break;\n            case 'JSON':\n                JSON.parse(String(value));\n                break;\n        }\n        \n        if (config.transform) {\n            value = config.transform(value);\n        }\n        \n        return value;\n    }\n    \n    protected setVariable(key: string, value: unknown): boolean {\n        const config = this.variables[key];\n        \n        if (!config) {\n            throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);\n        }\n        \n        if (config.transform) {\n            throw new EnvironmentVariableError('Setting environment variables with transform functions is not yet supported.');\n        }\n        \n        switch (config.type) {\n            case 'BOOLEAN':\n            case 'NUMBER':\n            case 'default':\n                process.env[key] = String(value);\n                return true;\n            case 'JSON':\n                process.env[key] = JSON.stringify(value);\n                return true;\n        }\n        \n        throw new EnvironmentVariableError(`Invalid type '${config.type}' for environment variable '${key}'`);\n    }\n}\n\nexport type EnvironmentVariablesInstance<TVariables extends VariableDefinitionMap> = EnvironmentVariables<TVariables> & {\n    [key in keyof TVariables]: VariableOutputType<TVariables[key]>;\n}","import { EnvironmentVariables, type EnvironmentVariablesInstance } from './EnvironmentVariables.ts';\nimport type { VariableDefinitionMap } from './Types.ts';\n\nexport function defineEnvironmentVariables<\n    TVariables extends VariableDefinitionMap\n>(variables: TVariables): EnvironmentVariablesInstance<TVariables> {\n    const instance = new EnvironmentVariables(variables);\n    \n    instance.validate();\n    \n    // @ts-expect-error Type mismatch between result and explicit return type\n    return instance;\n}\n\n"],"mappings":";;;AAEA,IAAa,2BAAb,cAA8C,MAAM;AAGpD,IAAa,mCAAb,cAAsD,yBAAyB;CAC3E,YAAY,AAAgB,QAAsD;AAC9E,QAAM,kCAAkC,OAAO,KAAK,iEAAiE;EAD7F;;;;;;ACFhC,IAAa,uBAAb,MAA4E;CACxE,YAAY,AAAmB,WAAuB;EAAvB;AAC3B,SAAO,IAAI,MAAM,MAAM;GACnB,IAAI,QAAQ,MAAM,UAAU;AACxB,QAAI,QAAQ,OACR,QAAO,QAAQ,IAAI,QAAQ,MAAM,SAAS;AAE9C,WAAO,OAAO,YAAY,KAAe;;GAE7C,IAAI,QAAQ,MAAM,OAAO,UAAU;AAC/B,WAAO,OAAO,YAAY,MAAgB,MAAM;;GAEvD,CAAC;;CAGN,AAAO,WAAiB;AACpB,OAAK,2BAA2B;;CAGpC,AAAU,4BAAkC;AACxC,SAAO,QAAQ,KAAK,UAAU,CAAC,SAAS,CAAC,KAAK,YAAY;AACtD,OAAI,CAAC,OAAO,SACR;AAKJ,OAAI,OAFU,KAAK,YAAY,IAAI,KAEd,YACjB,OAAM,IAAI,iCAAiC,OAAO,OAAO,EAAE,MAAM,KAAK,EAAE,OAAO,CAAC;IAEtF;;CAGN,AAAU,YAAY,KAAsB;EACxC,MAAM,SAAS,KAAK,UAAU;AAE9B,MAAI,CAAC,OACD,OAAM,IAAI,yBAAyB,oDAAoD,IAAI,GAAG;EAGlG,MAAM,gBAAgB,QAAQ,IAAI,QAAQ,OAAO;EACjD,IAAI,QAAiB;EACrB,MAAM,OAAO,OAAO,QAAQ;AAE5B,MAAI,OAAO,YAAY,OAAO,UAAU,YACpC,OAAM,IAAI,iCAAiC,OAAO,OAAO,EAAE,MAAM,KAAK,EAAE,OAAO,CAAC;AAGpF,UAAQ,MAAR;GACI,KAAK;AACD,+CAAgB,IAAI;AACpB;GACJ,KAAK;AACD,YAAQ,OAAO,MAAM;AACrB,QAAI,OAAO,MAAM,MAAM,CACnB,OAAM,IAAI,yBAAyB,4BAA4B,IAAI,KAAK,gBAAgB;AAE5F;GACJ,KAAK;AACD,SAAK,MAAM,OAAO,MAAM,CAAC;AACzB;;AAGR,MAAI,OAAO,UACP,SAAQ,OAAO,UAAU,MAAM;AAGnC,SAAO;;CAGX,AAAU,YAAY,KAAa,OAAyB;EACxD,MAAM,SAAS,KAAK,UAAU;AAE9B,MAAI,CAAC,OACD,OAAM,IAAI,yBAAyB,oDAAoD,IAAI,GAAG;AAGlG,MAAI,OAAO,UACP,OAAM,IAAI,yBAAyB,+EAA+E;AAGtH,UAAQ,OAAO,MAAf;GACI,KAAK;GACL,KAAK;GACL,KAAK;AACD,YAAQ,IAAI,OAAO,OAAO,MAAM;AAChC,WAAO;GACX,KAAK;AACD,YAAQ,IAAI,OAAO,KAAK,UAAU,MAAM;AACxC,WAAO;;AAGf,QAAM,IAAI,yBAAyB,iBAAiB,OAAO,KAAK,8BAA8B,IAAI,GAAG;;;;;;AC7F7G,SAAgB,2BAEd,WAAiE;CAC/D,MAAM,WAAW,IAAI,qBAAqB,UAAU;AAEpD,UAAS,UAAU;AAGnB,QAAO"}

package/dist/index.d.cts

@@ -0,0 +1,45 @@
+//#region src/environment/Types.d.ts
+interface EnvironmentVariableConfig<TRequired extends boolean = boolean, TTypeCast extends keyof VariableTypeCast = keyof VariableTypeCast, TTransform = unknown> {
+  required?: TRequired;
+  type?: TTypeCast;
+  default?: VariableTypeCast[TTypeCast];
+  transform?: TransformFn<any, TTransform>;
+}
+type VariableDefinitionMap = { [key in keyof NodeJS.ProcessEnv]: EnvironmentVariableConfig };
+type VariableOutputType<TConfig extends EnvironmentVariableConfig, TTypeCast extends keyof VariableTypeCast = (TConfig['type'] extends keyof VariableTypeCast ? TConfig['type'] : 'default'), TType = VariableTypeCast[TTypeCast], TCastOutputType = (TConfig['required'] extends true ? TType : TType | undefined)> = TConfig['transform'] extends TransformFn<TCastOutputType, infer TTransformOutput> ? TTransformOutput : TCastOutputType;
+type TransformFn<TInput, TOutput> = (value: TInput) => TOutput;
+interface VariableTypeCast {
+  /**
+       * Default type for environment variables.
+       */
+  default: string;
+  /**
+       * Boolean flag (1, 0, true, false, yes, no)
+       */
+  BOOLEAN: boolean;
+  /**
+       * Cast inputs to number.
+       */
+  NUMBER: number;
+  /**
+       * Parse input as JSON
+       */
+  JSON: unknown;
+}
+//#endregion
+//#region src/environment/EnvironmentVariables.d.ts
+declare class EnvironmentVariables<TVariables extends VariableDefinitionMap> {
+  protected readonly variables: TVariables;
+  constructor(variables: TVariables);
+  validate(): void;
+  protected validateRequiredVariables(): void;
+  protected getVariable(key: string): unknown;
+  protected setVariable(key: string, value: unknown): boolean;
+}
+type EnvironmentVariablesInstance<TVariables extends VariableDefinitionMap> = EnvironmentVariables<TVariables> & { [key in keyof TVariables]: VariableOutputType<TVariables[key]> };
+//#endregion
+//#region src/environment/defineEnvironmentVariables.d.ts
+declare function defineEnvironmentVariables<TVariables extends VariableDefinitionMap>(variables: TVariables): EnvironmentVariablesInstance<TVariables>;
+//#endregion
+export { defineEnvironmentVariables };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,45 @@
+//#region src/environment/Types.d.ts
+interface EnvironmentVariableConfig<TRequired extends boolean = boolean, TTypeCast extends keyof VariableTypeCast = keyof VariableTypeCast, TTransform = unknown> {
+  required?: TRequired;
+  type?: TTypeCast;
+  default?: VariableTypeCast[TTypeCast];
+  transform?: TransformFn<any, TTransform>;
+}
+type VariableDefinitionMap = { [key in keyof NodeJS.ProcessEnv]: EnvironmentVariableConfig };
+type VariableOutputType<TConfig extends EnvironmentVariableConfig, TTypeCast extends keyof VariableTypeCast = (TConfig['type'] extends keyof VariableTypeCast ? TConfig['type'] : 'default'), TType = VariableTypeCast[TTypeCast], TCastOutputType = (TConfig['required'] extends true ? TType : TType | undefined)> = TConfig['transform'] extends TransformFn<TCastOutputType, infer TTransformOutput> ? TTransformOutput : TCastOutputType;
+type TransformFn<TInput, TOutput> = (value: TInput) => TOutput;
+interface VariableTypeCast {
+  /**
+       * Default type for environment variables.
+       */
+  default: string;
+  /**
+       * Boolean flag (1, 0, true, false, yes, no)
+       */
+  BOOLEAN: boolean;
+  /**
+       * Cast inputs to number.
+       */
+  NUMBER: number;
+  /**
+       * Parse input as JSON
+       */
+  JSON: unknown;
+}
+//#endregion
+//#region src/environment/EnvironmentVariables.d.ts
+declare class EnvironmentVariables<TVariables extends VariableDefinitionMap> {
+  protected readonly variables: TVariables;
+  constructor(variables: TVariables);
+  validate(): void;
+  protected validateRequiredVariables(): void;
+  protected getVariable(key: string): unknown;
+  protected setVariable(key: string, value: unknown): boolean;
+}
+type EnvironmentVariablesInstance<TVariables extends VariableDefinitionMap> = EnvironmentVariables<TVariables> & { [key in keyof TVariables]: VariableOutputType<TVariables[key]> };
+//#endregion
+//#region src/environment/defineEnvironmentVariables.d.ts
+declare function defineEnvironmentVariables<TVariables extends VariableDefinitionMap>(variables: TVariables): EnvironmentVariablesInstance<TVariables>;
+//#endregion
+export { defineEnvironmentVariables };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,86 @@
+import { envFlag } from "@wcaservices/util/lib";
+
+//#region src/environment/Errors.ts
+var EnvironmentVariableError = class extends Error {};
+var RequiredEnvironmentVariableError = class extends EnvironmentVariableError {
+	constructor(config) {
+		super(`Required environment variable "${config.name}" is missing. Make sure one is set before starting the process!`);
+		this.config = config;
+	}
+};
+
+//#endregion
+//#region src/environment/EnvironmentVariables.ts
+var EnvironmentVariables = class {
+	constructor(variables) {
+		this.variables = variables;
+		return new Proxy(this, {
+			get(target, prop, receiver) {
+				if (prop in target) return Reflect.get(target, prop, receiver);
+				return target.getVariable(prop);
+			},
+			set(target, prop, value, receiver) {
+				return target.setVariable(prop, value);
+			}
+		});
+	}
+	validate() {
+		this.validateRequiredVariables();
+	}
+	validateRequiredVariables() {
+		Object.entries(this.variables).forEach(([key, config]) => {
+			if (!config.required) return;
+			if (typeof this.getVariable(key) === "undefined") throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));
+		});
+	}
+	getVariable(key) {
+		const config = this.variables[key];
+		if (!config) throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);
+		const originalValue = process.env[key] ?? config.default;
+		let value = originalValue;
+		const cast = config.type ?? "default";
+		if (config.required && typeof value === "undefined") throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));
+		switch (cast) {
+			case "BOOLEAN":
+				value = envFlag(key);
+				break;
+			case "NUMBER":
+				value = Number(value);
+				if (Number.isNaN(value)) throw new EnvironmentVariableError(`Invalid number type for '${key}': ${originalValue}`);
+				break;
+			case "JSON":
+				JSON.parse(String(value));
+				break;
+		}
+		if (config.transform) value = config.transform(value);
+		return value;
+	}
+	setVariable(key, value) {
+		const config = this.variables[key];
+		if (!config) throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);
+		if (config.transform) throw new EnvironmentVariableError("Setting environment variables with transform functions is not yet supported.");
+		switch (config.type) {
+			case "BOOLEAN":
+			case "NUMBER":
+			case "default":
+				process.env[key] = String(value);
+				return true;
+			case "JSON":
+				process.env[key] = JSON.stringify(value);
+				return true;
+		}
+		throw new EnvironmentVariableError(`Invalid type '${config.type}' for environment variable '${key}'`);
+	}
+};
+
+//#endregion
+//#region src/environment/defineEnvironmentVariables.ts
+function defineEnvironmentVariables(variables) {
+	const instance = new EnvironmentVariables(variables);
+	instance.validate();
+	return instance;
+}
+
+//#endregion
+export { defineEnvironmentVariables };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/environment/Errors.ts","../src/environment/EnvironmentVariables.ts","../src/environment/defineEnvironmentVariables.ts"],"sourcesContent":["import type { EnvironmentVariableConfig } from './Types.ts';\n\nexport class EnvironmentVariableError extends Error {\n}\n\nexport class RequiredEnvironmentVariableError extends EnvironmentVariableError {\n    constructor(public readonly config: EnvironmentVariableConfig & { name: string }) {\n        super(`Required environment variable \"${config.name}\" is missing. Make sure one is set before starting the process!`);\n    }\n}","import { envFlag } from '@wcaservices/util/lib';\nimport { EnvironmentVariableError, RequiredEnvironmentVariableError } from './Errors.ts';\nimport type { VariableDefinitionMap, VariableOutputType } from './Types.ts';\n\nexport class EnvironmentVariables<TVariables extends VariableDefinitionMap> {\n    constructor(protected readonly variables: TVariables) {\n        return new Proxy(this, {\n            get(target, prop, receiver) {\n                if (prop in target) {\n                    return Reflect.get(target, prop, receiver);\n                }\n                return target.getVariable(prop as string);\n            },\n            set(target, prop, value, receiver) {\n                return target.setVariable(prop as string, value);\n            }\n        })\n    }\n    \n    public validate(): void {\n        this.validateRequiredVariables();\n    }\n    \n    protected validateRequiredVariables(): void {\n        Object.entries(this.variables).forEach(([key, config]) => {\n            if (!config.required) {\n                return;\n            }\n            \n            const value = this.getVariable(key);\n            \n            if (typeof value === 'undefined') {\n                throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));\n            }\n        })\n    }\n    \n    protected getVariable(key: string): unknown {\n        const config = this.variables[key];\n        \n        if (!config) {\n            throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);\n        }\n        \n        const originalValue = process.env[key] ?? config.default;\n        let value: unknown = originalValue;\n        const cast = config.type ?? 'default';\n        \n        if (config.required && typeof value === 'undefined') {\n            throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));\n        }\n        \n        switch (cast) {\n            case 'BOOLEAN':\n                value = envFlag(key);\n                break;\n            case 'NUMBER':\n                value = Number(value);\n                if (Number.isNaN(value)) {\n                    throw new EnvironmentVariableError(`Invalid number type for '${key}': ${originalValue}`);\n                }\n                break;\n            case 'JSON':\n                JSON.parse(String(value));\n                break;\n        }\n        \n        if (config.transform) {\n            value = config.transform(value);\n        }\n        \n        return value;\n    }\n    \n    protected setVariable(key: string, value: unknown): boolean {\n        const config = this.variables[key];\n        \n        if (!config) {\n            throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);\n        }\n        \n        if (config.transform) {\n            throw new EnvironmentVariableError('Setting environment variables with transform functions is not yet supported.');\n        }\n        \n        switch (config.type) {\n            case 'BOOLEAN':\n            case 'NUMBER':\n            case 'default':\n                process.env[key] = String(value);\n                return true;\n            case 'JSON':\n                process.env[key] = JSON.stringify(value);\n                return true;\n        }\n        \n        throw new EnvironmentVariableError(`Invalid type '${config.type}' for environment variable '${key}'`);\n    }\n}\n\nexport type EnvironmentVariablesInstance<TVariables extends VariableDefinitionMap> = EnvironmentVariables<TVariables> & {\n    [key in keyof TVariables]: VariableOutputType<TVariables[key]>;\n}","import { EnvironmentVariables, type EnvironmentVariablesInstance } from './EnvironmentVariables.ts';\nimport type { VariableDefinitionMap } from './Types.ts';\n\nexport function defineEnvironmentVariables<\n    TVariables extends VariableDefinitionMap\n>(variables: TVariables): EnvironmentVariablesInstance<TVariables> {\n    const instance = new EnvironmentVariables(variables);\n    \n    instance.validate();\n    \n    // @ts-expect-error Type mismatch between result and explicit return type\n    return instance;\n}\n\n"],"mappings":";;;AAEA,IAAa,2BAAb,cAA8C,MAAM;AAGpD,IAAa,mCAAb,cAAsD,yBAAyB;CAC3E,YAAY,AAAgB,QAAsD;AAC9E,QAAM,kCAAkC,OAAO,KAAK,iEAAiE;EAD7F;;;;;;ACFhC,IAAa,uBAAb,MAA4E;CACxE,YAAY,AAAmB,WAAuB;EAAvB;AAC3B,SAAO,IAAI,MAAM,MAAM;GACnB,IAAI,QAAQ,MAAM,UAAU;AACxB,QAAI,QAAQ,OACR,QAAO,QAAQ,IAAI,QAAQ,MAAM,SAAS;AAE9C,WAAO,OAAO,YAAY,KAAe;;GAE7C,IAAI,QAAQ,MAAM,OAAO,UAAU;AAC/B,WAAO,OAAO,YAAY,MAAgB,MAAM;;GAEvD,CAAC;;CAGN,AAAO,WAAiB;AACpB,OAAK,2BAA2B;;CAGpC,AAAU,4BAAkC;AACxC,SAAO,QAAQ,KAAK,UAAU,CAAC,SAAS,CAAC,KAAK,YAAY;AACtD,OAAI,CAAC,OAAO,SACR;AAKJ,OAAI,OAFU,KAAK,YAAY,IAAI,KAEd,YACjB,OAAM,IAAI,iCAAiC,OAAO,OAAO,EAAE,MAAM,KAAK,EAAE,OAAO,CAAC;IAEtF;;CAGN,AAAU,YAAY,KAAsB;EACxC,MAAM,SAAS,KAAK,UAAU;AAE9B,MAAI,CAAC,OACD,OAAM,IAAI,yBAAyB,oDAAoD,IAAI,GAAG;EAGlG,MAAM,gBAAgB,QAAQ,IAAI,QAAQ,OAAO;EACjD,IAAI,QAAiB;EACrB,MAAM,OAAO,OAAO,QAAQ;AAE5B,MAAI,OAAO,YAAY,OAAO,UAAU,YACpC,OAAM,IAAI,iCAAiC,OAAO,OAAO,EAAE,MAAM,KAAK,EAAE,OAAO,CAAC;AAGpF,UAAQ,MAAR;GACI,KAAK;AACD,YAAQ,QAAQ,IAAI;AACpB;GACJ,KAAK;AACD,YAAQ,OAAO,MAAM;AACrB,QAAI,OAAO,MAAM,MAAM,CACnB,OAAM,IAAI,yBAAyB,4BAA4B,IAAI,KAAK,gBAAgB;AAE5F;GACJ,KAAK;AACD,SAAK,MAAM,OAAO,MAAM,CAAC;AACzB;;AAGR,MAAI,OAAO,UACP,SAAQ,OAAO,UAAU,MAAM;AAGnC,SAAO;;CAGX,AAAU,YAAY,KAAa,OAAyB;EACxD,MAAM,SAAS,KAAK,UAAU;AAE9B,MAAI,CAAC,OACD,OAAM,IAAI,yBAAyB,oDAAoD,IAAI,GAAG;AAGlG,MAAI,OAAO,UACP,OAAM,IAAI,yBAAyB,+EAA+E;AAGtH,UAAQ,OAAO,MAAf;GACI,KAAK;GACL,KAAK;GACL,KAAK;AACD,YAAQ,IAAI,OAAO,OAAO,MAAM;AAChC,WAAO;GACX,KAAK;AACD,YAAQ,IAAI,OAAO,KAAK,UAAU,MAAM;AACxC,WAAO;;AAGf,QAAM,IAAI,yBAAyB,iBAAiB,OAAO,KAAK,8BAA8B,IAAI,GAAG;;;;;;AC7F7G,SAAgB,2BAEd,WAAiE;CAC/D,MAAM,WAAW,IAAI,qBAAqB,UAAU;AAEpD,UAAS,UAAU;AAGnB,QAAO"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wcaservices/config",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "",
   "license": "ISC",
   "author": "Jørgen Vatle <Jorgen@WcAServices.net> (https://github.com/JorgenVatle)",
@@ -12,7 +12,7 @@
     "lint": "tsgo --noEmit"
   },
   "files": [
-    "src"
+    "dist"
   ],
   "exports": {
     "types": "./dist/index.d.mts",

package/src/environment/EnvironmentVariables.ts

@@ -1,103 +0,0 @@
-import { envFlag } from '@wcaservices/util/lib';
-import { EnvironmentVariableError, RequiredEnvironmentVariableError } from './Errors.ts';
-import type { VariableDefinitionMap, VariableOutputType } from './Types.ts';
-
-export class EnvironmentVariables<TVariables extends VariableDefinitionMap> {
-    constructor(protected readonly variables: TVariables) {
-        return new Proxy(this, {
-            get(target, prop, receiver) {
-                if (prop in target) {
-                    return Reflect.get(target, prop, receiver);
-                }
-                return target.getVariable(prop as string);
-            },
-            set(target, prop, value, receiver) {
-                return target.setVariable(prop as string, value);
-            }
-        })
-    }
-    
-    public validate(): void {
-        this.validateRequiredVariables();
-    }
-    
-    protected validateRequiredVariables(): void {
-        Object.entries(this.variables).forEach(([key, config]) => {
-            if (!config.required) {
-                return;
-            }
-            
-            const value = this.getVariable(key);
-            
-            if (typeof value === 'undefined') {
-                throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));
-            }
-        })
-    }
-    
-    protected getVariable(key: string): unknown {
-        const config = this.variables[key];
-        
-        if (!config) {
-            throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);
-        }
-        
-        const originalValue = process.env[key] ?? config.default;
-        let value: unknown = originalValue;
-        const cast = config.type ?? 'default';
-        
-        if (config.required && typeof value === 'undefined') {
-            throw new RequiredEnvironmentVariableError(Object.assign({ name: key }, config));
-        }
-        
-        switch (cast) {
-            case 'BOOLEAN':
-                value = envFlag(key);
-                break;
-            case 'NUMBER':
-                value = Number(value);
-                if (Number.isNaN(value)) {
-                    throw new EnvironmentVariableError(`Invalid number type for '${key}': ${originalValue}`);
-                }
-                break;
-            case 'JSON':
-                JSON.parse(String(value));
-                break;
-        }
-        
-        if (config.transform) {
-            value = config.transform(value);
-        }
-        
-        return value;
-    }
-    
-    protected setVariable(key: string, value: unknown): boolean {
-        const config = this.variables[key];
-        
-        if (!config) {
-            throw new EnvironmentVariableError(`No configuration found for environment variable '${key}'`);
-        }
-        
-        if (config.transform) {
-            throw new EnvironmentVariableError('Setting environment variables with transform functions is not yet supported.');
-        }
-        
-        switch (config.type) {
-            case 'BOOLEAN':
-            case 'NUMBER':
-            case 'default':
-                process.env[key] = String(value);
-                return true;
-            case 'JSON':
-                process.env[key] = JSON.stringify(value);
-                return true;
-        }
-        
-        throw new EnvironmentVariableError(`Invalid type '${config.type}' for environment variable '${key}'`);
-    }
-}
-
-export type EnvironmentVariablesInstance<TVariables extends VariableDefinitionMap> = EnvironmentVariables<TVariables> & {
-    [key in keyof TVariables]: VariableOutputType<TVariables[key]>;
-}

package/src/environment/Errors.ts

@@ -1,10 +0,0 @@
-import type { EnvironmentVariableConfig } from './Types.ts';
-
-export class EnvironmentVariableError extends Error {
-}
-
-export class RequiredEnvironmentVariableError extends EnvironmentVariableError {
-    constructor(public readonly config: EnvironmentVariableConfig & { name: string }) {
-        super(`Required environment variable "${config.name}" is missing. Make sure one is set before starting the process!`);
-    }
-}

package/src/environment/Types.ts

@@ -1,50 +0,0 @@
-export interface EnvironmentVariableConfig<
-    TRequired extends boolean = boolean,
-    TTypeCast extends keyof VariableTypeCast = keyof VariableTypeCast,
-    TTransform = unknown
-> {
-    required?: TRequired;
-    type?: TTypeCast;
-    default?: VariableTypeCast[TTypeCast];
-    transform?: TransformFn<any, TTransform>;
-}
-
-export type VariableDefinitionMap = {
-    [key in keyof NodeJS.ProcessEnv]: EnvironmentVariableConfig;
-}
-export type VariableOutputType<
-    TConfig extends EnvironmentVariableConfig,
-    TTypeCast extends keyof VariableTypeCast = TConfig['type'] extends keyof VariableTypeCast
-                                               ? TConfig['type']
-                                               : 'default',
-    TType = VariableTypeCast[TTypeCast],
-    TCastOutputType = TConfig['required'] extends true
-                      ? TType
-                      : TType | undefined,
-> = TConfig['transform'] extends TransformFn<TCastOutputType, infer TTransformOutput>
-    ? TTransformOutput
-    : TCastOutputType;
-
-type TransformFn<TInput, TOutput> = (value: TInput) => TOutput;
-
-interface VariableTypeCast {
-    /**
-     * Default type for environment variables.
-     */
-    default: string;
-    
-    /**
-     * Boolean flag (1, 0, true, false, yes, no)
-     */
-    BOOLEAN: boolean;
-    
-    /**
-     * Cast inputs to number.
-     */
-    NUMBER: number;
-    
-    /**
-     * Parse input as JSON
-     */
-    JSON: unknown; // todo
-}

package/src/environment/defineEnvironmentVariables.test-d.ts

@@ -1,162 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-import { defineEnvironmentVariables } from './defineEnvironmentVariables.ts';
-
-describe('Type inference for string types', () => {
-    const env = defineEnvironmentVariables({
-        NON_REQUIRED_ENV_VAR: {},
-        REQUIRED_ENV_VAR: { required: true },
-    });
-    
-    it('Only yields the configured variables', () => {
-        expectTypeOf(env).toMatchTypeOf<{
-            REQUIRED_ENV_VAR: string,
-            NON_REQUIRED_ENV_VAR: string | undefined
-        }>();
-        
-        expectTypeOf(env).not.toMatchTypeOf<{
-            REQUIRED_ENV_VAR: string,
-            NON_REQUIRED_ENV_VAR: string | undefined,
-            UNKNOWN_REQUIRED_ENV_VAR: string,
-            UNKNOWN_NON_REQUIRED_ENV_VAR: string | undefined
-        }>();
-    })
-    
-    it('Should yield string or undefined for non-required variables', () => {
-        expectTypeOf(env.NON_REQUIRED_ENV_VAR).toEqualTypeOf<string | undefined>();
-        expectTypeOf(env.NON_REQUIRED_ENV_VAR).not.toEqualTypeOf<string>();
-    })
-    
-    it(`Should omit 'undefined' type for required variables`, () => {
-        expectTypeOf(env.REQUIRED_ENV_VAR).toEqualTypeOf<string>();
-        expectTypeOf(env.REQUIRED_ENV_VAR).not.toEqualTypeOf<undefined>();
-        expectTypeOf(env.REQUIRED_ENV_VAR).not.toEqualTypeOf<undefined>();
-    });
-})
-
-describe('Type inference for NUMBER types', () => {
-    const env = defineEnvironmentVariables({
-        NON_REQUIRED_ENV_VAR: { type: 'NUMBER' },
-        REQUIRED_ENV_VAR: { type: 'NUMBER', required: true },
-    });
-    
-    it('Only yields the configured variables', () => {
-        expectTypeOf(env).toMatchTypeOf<{
-            REQUIRED_ENV_VAR: number,
-            NON_REQUIRED_ENV_VAR: number | undefined
-        }>();
-        
-        expectTypeOf(env).not.toMatchTypeOf<{
-            REQUIRED_ENV_VAR: number,
-            NON_REQUIRED_ENV_VAR: number | undefined,
-            UNKNOWN_REQUIRED_ENV_VAR: number,
-            UNKNOWN_NON_REQUIRED_ENV_VAR: number | undefined
-        }>();
-    })
-    
-    it('Should yield number or undefined for non-required variables', () => {
-        expectTypeOf(env.NON_REQUIRED_ENV_VAR).toEqualTypeOf<number | undefined>();
-        expectTypeOf(env.NON_REQUIRED_ENV_VAR).not.toEqualTypeOf<number>();
-    })
-    
-    it(`Should omit 'undefined' type for required variables`, () => {
-        expectTypeOf(env.REQUIRED_ENV_VAR).toEqualTypeOf<number>();
-        expectTypeOf(env.REQUIRED_ENV_VAR).not.toEqualTypeOf<undefined>();
-        expectTypeOf(env.REQUIRED_ENV_VAR).not.toEqualTypeOf<undefined>();
-    });
-});
-
-
-describe('Type inference for BOOLEAN types', () => {
-    const env = defineEnvironmentVariables({
-        NON_REQUIRED_ENV_VAR: { type: 'BOOLEAN' },
-        REQUIRED_ENV_VAR: { type: 'BOOLEAN', required: true },
-    });
-    
-    it('Only yields the configured variables', () => {
-        expectTypeOf(env).toMatchTypeOf<{
-            REQUIRED_ENV_VAR: boolean,
-            NON_REQUIRED_ENV_VAR: boolean | undefined
-        }>();
-        
-        expectTypeOf(env).not.toMatchTypeOf<{
-            REQUIRED_ENV_VAR: boolean,
-            NON_REQUIRED_ENV_VAR: boolean | undefined,
-            UNKNOWN_REQUIRED_ENV_VAR: boolean,
-            UNKNOWN_NON_REQUIRED_ENV_VAR: boolean | undefined
-        }>();
-    })
-    
-    it('Should yield boolean or undefined for non-required variables', () => {
-        expectTypeOf(env.NON_REQUIRED_ENV_VAR).toEqualTypeOf<boolean | undefined>();
-        expectTypeOf(env.NON_REQUIRED_ENV_VAR).not.toEqualTypeOf<boolean>();
-    })
-    
-    it(`Should omit 'undefined' type for required variables`, () => {
-        expectTypeOf(env.REQUIRED_ENV_VAR).toEqualTypeOf<boolean>();
-        expectTypeOf(env.REQUIRED_ENV_VAR).not.toEqualTypeOf<undefined>();
-        expectTypeOf(env.REQUIRED_ENV_VAR).not.toEqualTypeOf<undefined>();
-    });
-});
-
-describe('Type inference with transformer functions', () => {
-    const env = defineEnvironmentVariables({
-        EXPLICIT_RETURN_TYPE: {
-            transform: (value): 'yes' | 'no' => value === 'yes' ? 'yes' : 'no',
-        },
-        IMPLICIT_RETURN_TYPE: {
-            transform: (value) => value === 'yes' ? 'yes' as const : 'no' as const,
-        },
-    });
-    
-    it('Can infer types with explicit return types', () => {
-        expectTypeOf(env.EXPLICIT_RETURN_TYPE).toEqualTypeOf<'yes' | 'no'>();
-    });
-    
-    it('Can infer types with implicit return types', () => {
-        expectTypeOf(env.IMPLICIT_RETURN_TYPE).toEqualTypeOf<'yes' | 'no'>();
-    });
-    
-    it.todo('Will infer input types for required variables', () => {
-        const env = defineEnvironmentVariables({
-            IMPLICIT_REQUIRED_ARGUMENT_TYPE: {
-                required: true,
-                transform: (value) => {
-                    // @ts-expect-error TODO: fix transform input type inference
-                    expectTypeOf(value).toEqualTypeOf<string>()
-                    return 'ok' as const;
-                }
-            },
-        });
-        
-        expectTypeOf(env.IMPLICIT_REQUIRED_ARGUMENT_TYPE).toEqualTypeOf<'ok'>();
-    });
-    
-    it.todo('Will infer input types for optional variables', () => {
-        const env = defineEnvironmentVariables({
-            IMPLICIT_OPTIONAL_ARGUMENT_TYPE: {
-                transform: (value) => {
-                    // @ts-expect-error TODO: fix transform input type inference
-                    expectTypeOf(value).toEqualTypeOf<string | undefined>()
-                    return 'ok' as const;
-                }
-            },
-        });
-        
-        expectTypeOf(env.IMPLICIT_OPTIONAL_ARGUMENT_TYPE).toEqualTypeOf<'ok'>();
-    });
-    
-    it('Will allow explicit argument types', () => {
-        const env = defineEnvironmentVariables({
-            EXPLICIT_REQUIRED_ARGUMENT_TYPE: {
-                required: true,
-                transform: (value: string) => 'ok' as const,
-            },
-            EXPLICIT_OPTIONAL_ARGUMENT_TYPE: {
-                transform: (value: string | undefined) => 'ok' as const,
-            },
-        });
-        
-        expectTypeOf(env.EXPLICIT_REQUIRED_ARGUMENT_TYPE).toEqualTypeOf<'ok'>();
-        expectTypeOf(env.EXPLICIT_OPTIONAL_ARGUMENT_TYPE).toEqualTypeOf<'ok'>();
-    })
-})

package/src/environment/defineEnvironmentVariables.test.ts

@@ -1,50 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { defineEnvironmentVariables } from './defineEnvironmentVariables.ts';
-import { RequiredEnvironmentVariableError } from './Errors.ts';
-
-const ORIGINAL_ENV = Object.freeze({
-    ...process.env,
-})
-
-describe('Environment variable parsing', () => {
-    beforeEach(() => {
-        process.env = {
-            ...ORIGINAL_ENV,
-            TEST_STRING_HELLO: 'world',
-            TEST_NUMBER_123: '123',
-            TEST_BOOLEAN_TRUE: 'true',
-            TEST_BOOLEAN_FALSE: 'false',
-        };
-    });
-    
-    it('should enforce required environment variables', () => {
-        expect(() => {
-            const env = defineEnvironmentVariables({
-                REQUIRED_ENV_VALUE: {
-                    required: true,
-                }
-            })
-        }).toThrow(RequiredEnvironmentVariableError);
-    });
-    
-    it('should apply transform functions', () => {
-        const transform = (value: boolean) => value ? 'yes' : 'no';
-        
-        const env = defineEnvironmentVariables({
-            TEST_BOOLEAN_TRUE: {
-                type: 'BOOLEAN',
-                required: true,
-                transform,
-            },
-            TEST_BOOLEAN_FALSE: {
-                type: 'BOOLEAN',
-                required: true,
-                transform,
-            }
-        });
-        
-        expect(env.TEST_BOOLEAN_TRUE).toEqual('yes');
-        expect(env.TEST_BOOLEAN_FALSE).toEqual('no');
-    })
-})
-

package/src/environment/defineEnvironmentVariables.ts

@@ -1,14 +0,0 @@
-import { EnvironmentVariables, type EnvironmentVariablesInstance } from './EnvironmentVariables.ts';
-import type { VariableDefinitionMap } from './Types.ts';
-
-export function defineEnvironmentVariables<
-    TVariables extends VariableDefinitionMap
->(variables: TVariables): EnvironmentVariablesInstance<TVariables> {
-    const instance = new EnvironmentVariables(variables);
-    
-    instance.validate();
-    
-    // @ts-expect-error Type mismatch between result and explicit return type
-    return instance;
-}
-

package/src/environment/index.ts

@@ -1 +0,0 @@
-export * from './defineEnvironmentVariables';

package/src/index.ts

@@ -1 +0,0 @@
-export * from './environment';