@jeengbe/config 0.0.0

package/dist/ast.d.mts

@@ -0,0 +1,24 @@
+import { ValidationResult } from "@prisjakt/utils";
+//#region src/ast.d.ts
+declare const nodeType: unique symbol;
+declare class EnvNode<T> {
+  readonly validate: (path: string, loadValue: (key: string) => string | undefined) => ValidationResult<T>;
+  private readonly [nodeType];
+  constructor(validate: (path: string, loadValue: (key: string) => string | undefined) => ValidationResult<T>);
+  transform<U>(transform: (value: T) => ValidationResult<U>): EnvNode<U>;
+}
+declare class ScalarEnvNode<T> extends EnvNode<T> {
+  readonly key: string;
+  private readonly validateValue;
+  constructor(key: string, validateValue: (value: string | undefined) => ValidationResult<T>);
+  optional(): ScalarEnvNode<T | undefined>;
+  transform<U>(transform: (value: T) => ValidationResult<U>): ScalarEnvNode<U>;
+}
+type EnvSpec = EnvNode<unknown> | {
+  [key: string]: EnvSpec;
+};
+type InferEnvSpec<T extends EnvSpec> = T extends EnvNode<infer U> ? U : T extends Record<string, EnvSpec> ? { [K in keyof T]: InferEnvSpec<T[K]>; } : never;
+type Pretty<T> = T extends (infer U extends object) ? { [K in keyof U]: Pretty<U[K]>; } : T;
+//#endregion
+export { EnvNode, EnvSpec, InferEnvSpec, Pretty, ScalarEnvNode };
+//# sourceMappingURL=ast.d.mts.map

package/dist/ast.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.mts","names":[],"sources":["../src/ast.ts"],"mappings":";;cAEM;cAEO,QAAQ;WAIR,WACP,cACA,YAAY,uCACT,iBAAiB;oBANE;EAE1B,YACW,WACP,cACA,YAAY,uCACT,iBAAiB;EAGxB,UAAU,GAAG,YAAY,OAAO,MAAM,iBAAiB,KAAK,QAAQ;;cAOzD,cAAc,WAAW,QAAQ;WAEjC;mBACQ;EAFnB,YACW,aACQ,gBACf,8BACG,iBAAiB;EASxB,YAAY,cAAc;EAM1B,UAAU,GAAG,YAAY,OAAO,MAAM,iBAAiB,KAAK,cAAc;;KAOhE,UAAU;GAAsB,cAAc;;KAE9C,aAAa,UAAU,WACjC,UAAU,cAAc,KACpB,IACA,UAAU,eAAe,cACpB,WAAW,IAAI,aAAa,EAAE;KAG7B,OAAO,KAAK,iBAAgB,uBACjC,WAAW,IAAI,OAAO,EAAE,SAC3B"}

package/dist/ast.mjs

@@ -0,0 +1,34 @@
+import { Either } from "@prisjakt/utils";
+
+//#region src/ast.ts
+const nodeType = Symbol("type");
+var EnvNode = class EnvNode {
+	validate;
+	constructor(validate) {
+		this.validate = validate;
+	}
+	transform(transform) {
+		return new EnvNode((path, loadValue) => this.validate(path, loadValue).flatMap(transform));
+	}
+};
+var ScalarEnvNode = class ScalarEnvNode extends EnvNode {
+	key;
+	validateValue;
+	constructor(key, validateValue) {
+		super((path, loadValue) => {
+			return validateValue(loadValue(key)).leftMap((errors) => errors.map((error) => `${key} (${path}): ${error}`));
+		});
+		this.key = key;
+		this.validateValue = validateValue;
+	}
+	optional() {
+		return new ScalarEnvNode(this.key, (value) => value === undefined ? Either.right(undefined) : this.validateValue(value));
+	}
+	transform(transform) {
+		return new ScalarEnvNode(this.key, (value) => this.validateValue(value).flatMap(transform));
+	}
+};
+
+//#endregion
+export { EnvNode, ScalarEnvNode };
+//# sourceMappingURL=ast.mjs.map

package/dist/ast.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.mjs","names":[],"sources":["../src/ast.ts"],"sourcesContent":["import { Either, ValidationResult } from '@prisjakt/utils';\n\nconst nodeType = Symbol('type');\n\nexport class EnvNode<T> {\n  declare private readonly [nodeType]: T;\n\n  constructor(\n    readonly validate: (\n      path: string,\n      loadValue: (key: string) => string | undefined,\n    ) => ValidationResult<T>,\n  ) {}\n\n  transform<U>(transform: (value: T) => ValidationResult<U>): EnvNode<U> {\n    return new EnvNode((path, loadValue) =>\n      this.validate(path, loadValue).flatMap(transform),\n    );\n  }\n}\n\nexport class ScalarEnvNode<T> extends EnvNode<T> {\n  constructor(\n    readonly key: string,\n    private readonly validateValue: (\n      value: string | undefined,\n    ) => ValidationResult<T>,\n  ) {\n    super((path, loadValue) => {\n      return validateValue(loadValue(key)).leftMap((errors) =>\n        errors.map((error) => `${key} (${path}): ${error}`),\n      );\n    });\n  }\n\n  optional(): ScalarEnvNode<T | undefined> {\n    return new ScalarEnvNode<T | undefined>(this.key, (value) =>\n      value === undefined ? Either.right(undefined) : this.validateValue(value),\n    );\n  }\n\n  transform<U>(transform: (value: T) => ValidationResult<U>): ScalarEnvNode<U> {\n    return new ScalarEnvNode(this.key, (value) =>\n      this.validateValue(value).flatMap(transform),\n    );\n  }\n}\n\nexport type EnvSpec = EnvNode<unknown> | { [key: string]: EnvSpec };\n\nexport type InferEnvSpec<T extends EnvSpec> =\n  T extends EnvNode<infer U>\n    ? U\n    : T extends Record<string, EnvSpec>\n      ? { [K in keyof T]: InferEnvSpec<T[K]> }\n      : never;\n\nexport type Pretty<T> = T extends infer U extends object\n  ? { [K in keyof U]: Pretty<U[K]> }\n  : T;\n"],"mappings":";;;AAEA,MAAM,WAAW,OAAO,MAAM;AAE9B,IAAa,UAAb,MAAa,QAAW;CAIX;CADX,YACE,AAAS,UAIT;EAJS;CAIR;CAEH,UAAa,WAA0D;EACrE,OAAO,IAAI,SAAS,MAAM,cACxB,KAAK,SAAS,MAAM,SAAS,CAAC,CAAC,QAAQ,SAAS,CAClD;CACF;AACF;AAEA,IAAa,gBAAb,MAAa,sBAAyB,QAAW;CAEpC;CACQ;CAFnB,YACE,AAAS,KACT,AAAiB,eAGjB;EACA,OAAO,MAAM,cAAc;GACzB,OAAO,cAAc,UAAU,GAAG,CAAC,CAAC,CAAC,SAAS,WAC5C,OAAO,KAAK,UAAU,GAAG,IAAI,IAAI,KAAK,KAAK,OAAO,CACpD;EACF,CAAC;EATQ;EACQ;CASnB;CAEA,WAAyC;EACvC,OAAO,IAAI,cAA6B,KAAK,MAAM,UACjD,UAAU,YAAY,OAAO,MAAM,SAAS,IAAI,KAAK,cAAc,KAAK,CAC1E;CACF;CAEA,UAAa,WAAgE;EAC3E,OAAO,IAAI,cAAc,KAAK,MAAM,UAClC,KAAK,cAAc,KAAK,CAAC,CAAC,QAAQ,SAAS,CAC7C;CACF;AACF"}

package/dist/env.d.mts

@@ -0,0 +1,18 @@
+import { EnvNode, EnvSpec, InferEnvSpec, Pretty, ScalarEnvNode } from "./ast.mjs";
+import { ValidationResult } from "@prisjakt/utils";
+//#region src/env.d.ts
+declare const env: {
+  string(key: string, defaultValue?: string): ScalarEnvNode<string>;
+  number(key: string, defaultValue?: number): ScalarEnvNode<number>;
+  boolean(key: string, defaultValue?: boolean): ScalarEnvNode<boolean>;
+  enum<const T extends string>(key: string, values: readonly T[], defaultValue?: T): ScalarEnvNode<T>;
+  custom<T>(key: string, transform: (value: string) => ValidationResult<T>, defaultValue?: T): ScalarEnvNode<T>;
+  array<T>(itemType: ScalarEnvNode<T>, defaultValue?: readonly T[]): EnvNode<readonly T[]>;
+  discriminate<K extends string, V extends string, M extends Partial<Record<V, Record<string, EnvSpec>>>>(discriminatorKey: K, discriminatorValueType: ScalarEnvNode<V>, mapping: M): EnvNode<DiscriminatorResult<K, V, M>>;
+  load<S extends EnvSpec>(spec: S): Pretty<InferEnvSpec<S>>;
+};
+type DiscriminatorResult<K extends string, V extends string, M extends Partial<Record<V, Record<string, EnvSpec>>>> = Pretty<V extends unknown // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- It's used only in an intersection
+ ? Record<K, V> & InferEnvSpec<M[V] extends EnvSpec ? M[V] : {}> : never>;
+//#endregion
+export { env };
+//# sourceMappingURL=env.d.mts.map

package/dist/env.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.mts","names":[],"sources":["../src/env.ts"],"mappings":";;;cAgBa;EACX,OAAM,aAAY,wBAA0B;EAI5C,OAAM,aAAY,wBAA0B;EAc5C,QAAO,aAAY,yBAA2B;EAa9C,WAAW,kBAAgB,aACd,iBACM,KAAG,eACL,IACd,cAAc;EAcjB,OAAO,GAAC,aACK,YACC,kBAAkB,iBAAiB,IAAE,eAClC,IACd,cAAc;EAWjB,MAAM,GAAC,UACK,cAAc,IAAE,wBACF,MACvB,iBAAiB;EAsBpB,aACE,kBACA,kBACA,UAAU,QAAQ,OAAO,GAAG,eAAe,YAAU,kBAEnC,GAAC,wBACK,cAAc,IAAE,SAC/B,IACR,QAAQ,oBAAoB,GAAG,GAAG;EAqBrC,KAAK,UAAU,SAAO,MAAQ,IAAI,OAAO,aAAa;;KAYnD,oBACH,kBACA,kBACA,UAAU,QAAQ,OAAO,GAAG,eAAe,cACzC,OAGF;GAEI,OAAO,GAAG,KAAK,aAAa,EAAE,WAAW,UAAU,EAAE"}

package/dist/env.mjs

@@ -0,0 +1,75 @@
+import { EnvNode, ScalarEnvNode } from "./ast.mjs";
+import { Either, arrayIncludes, combineValidationResults } from "@prisjakt/utils";
+
+//#region src/env.ts
+const env = {
+	string(key, defaultValue) {
+		return env.custom(key, (value) => Either.right(value), defaultValue);
+	},
+	number(key, defaultValue) {
+		return env.custom(key, (value) => {
+			if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+				return Either.right(Number(value));
+			}
+			return Either.left(["invalid number"]);
+		}, defaultValue);
+	},
+	boolean(key, defaultValue) {
+		return env.custom(key, (value) => {
+			if (value.toLowerCase() === "true") return Either.right(true);
+			if (value.toLowerCase() === "false") return Either.right(false);
+			return Either.left(["invalid boolean (must be 'true' or 'false')"]);
+		}, defaultValue);
+	},
+	enum(key, values, defaultValue) {
+		return env.custom(key, (value) => {
+			if (arrayIncludes(values, value)) return Either.right(value);
+			return Either.left([`invalid enum value (must be one of: ${values.map((v) => `'${v}'`).join(", ")})`]);
+		}, defaultValue);
+	},
+	custom(key, transform, defaultValue) {
+		return new ScalarEnvNode(key, (value) => {
+			if (value === undefined) {
+				if (defaultValue !== undefined) return Either.right(defaultValue);
+				return Either.left(["required"]);
+			}
+			return transform(value);
+		});
+	},
+	array(itemType, defaultValue) {
+		return new EnvNode((path, loadValue) => {
+			const value = loadValue(itemType.key);
+			if (value === undefined) {
+				if (defaultValue !== undefined) return Either.right(defaultValue);
+				return Either.left([`${itemType.key} (${path}): required`]);
+			}
+			if (value === "") return Either.right([]);
+			return combineValidationResults(...value.split(",").map((v) => v.trim() || undefined).map((v, i) => itemType.validate(`${path}.${i}`, (k) => k === itemType.key ? v : undefined)));
+		});
+	},
+	discriminate(discriminatorKey, discriminatorValueType, mapping) {
+		return new EnvNode((path, loadValue) => {
+			return discriminatorValueType.validate(path, loadValue).flatMap((discriminatorValue) => {
+				return resolveNode(path, mapping[discriminatorValue] ?? {}, loadValue).map((mappingValues) => ({
+					[discriminatorKey]: discriminatorValue,
+					...mappingValues
+				}));
+			});
+		});
+	},
+	load(spec) {
+		return resolveNode("$", spec, (key) => process.env[key]?.trim() || undefined).getOrElse((errors) => {
+			throw new Error(`Failed to load config: ${errors.join(", ")}`);
+		});
+	}
+};
+function resolveNode(path, spec, loadValue) {
+	if (spec instanceof EnvNode) {
+		return spec.validate(path, loadValue);
+	}
+	return combineValidationResults(...Object.entries(spec).map(([key, value]) => resolveNode(`${path}.${key}`, value, loadValue).map((v) => [key, v]))).map((entries) => Object.fromEntries(entries));
+}
+
+//#endregion
+export { env };
+//# sourceMappingURL=env.mjs.map

package/dist/env.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.mjs","names":[],"sources":["../src/env.ts"],"sourcesContent":["import type {\n  ValidationResult} from '@prisjakt/utils';\nimport {\n  arrayIncludes,\n  combineValidationResults,\n  Either\n} from '@prisjakt/utils';\nimport type {\n  EnvSpec,\n  InferEnvSpec,\n  Pretty} from './ast.js';\nimport {\n  EnvNode,\n  ScalarEnvNode,\n} from './ast.js';\n\nexport const env = {\n  string(key: string, defaultValue?: string): ScalarEnvNode<string> {\n    return env.custom(key, (value) => Either.right(value), defaultValue);\n  },\n\n  number(key: string, defaultValue?: number): ScalarEnvNode<number> {\n    return env.custom(\n      key,\n      (value) => {\n        if (/^-?\\d+(?:\\.\\d+)?$/.test(value)) {\n          return Either.right(Number(value));\n        }\n\n        return Either.left(['invalid number']);\n      },\n      defaultValue,\n    );\n  },\n\n  boolean(key: string, defaultValue?: boolean): ScalarEnvNode<boolean> {\n    return env.custom(\n      key,\n      (value) => {\n        if (value.toLowerCase() === 'true') return Either.right(true);\n        if (value.toLowerCase() === 'false') return Either.right(false);\n\n        return Either.left([\"invalid boolean (must be 'true' or 'false')\"]);\n      },\n      defaultValue,\n    );\n  },\n\n  enum<const T extends string>(\n    key: string,\n    values: readonly T[],\n    defaultValue?: T,\n  ): ScalarEnvNode<T> {\n    return env.custom(\n      key,\n      (value) => {\n        if (arrayIncludes(values, value)) return Either.right(value);\n\n        return Either.left([\n          `invalid enum value (must be one of: ${values.map((v) => `'${v}'`).join(', ')})`,\n        ]);\n      },\n      defaultValue,\n    );\n  },\n\n  custom<T>(\n    key: string,\n    transform: (value: string) => ValidationResult<T>,\n    defaultValue?: T,\n  ): ScalarEnvNode<T> {\n    return new ScalarEnvNode(key, (value) => {\n      if (value === undefined) {\n        if (defaultValue !== undefined) return Either.right(defaultValue);\n        return Either.left(['required']);\n      }\n\n      return transform(value);\n    });\n  },\n\n  array<T>(\n    itemType: ScalarEnvNode<T>,\n    defaultValue?: readonly T[],\n  ): EnvNode<readonly T[]> {\n    return new EnvNode((path, loadValue) => {\n      const value = loadValue(itemType.key);\n      if (value === undefined) {\n        if (defaultValue !== undefined) return Either.right(defaultValue);\n        return Either.left([`${itemType.key} (${path}): required`]);\n      }\n      if (value === '') return Either.right([]);\n\n      return combineValidationResults(\n        ...value\n          .split(',')\n          .map((v) => v.trim() || undefined)\n          .map((v, i) =>\n            itemType.validate(`${path}.${i}`, (k) =>\n              k === itemType.key ? v : undefined,\n            ),\n          ),\n      );\n    });\n  },\n\n  discriminate<\n    K extends string,\n    V extends string,\n    M extends Partial<Record<V, Record<string, EnvSpec>>>,\n  >(\n    discriminatorKey: K,\n    discriminatorValueType: ScalarEnvNode<V>,\n    mapping: M,\n  ): EnvNode<DiscriminatorResult<K, V, M>> {\n    return new EnvNode((path, loadValue) => {\n      return discriminatorValueType\n        .validate(path, loadValue)\n        .flatMap((discriminatorValue) => {\n          // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- This is the type that we map over\n          return resolveNode<NonNullable<M[keyof M]> | {}>(\n            path,\n            mapping[discriminatorValue] ?? {},\n            loadValue,\n          ).map(\n            (mappingValues) =>\n              ({\n                [discriminatorKey]: discriminatorValue,\n                ...mappingValues,\n              }) as DiscriminatorResult<K, V, M>,\n          );\n        });\n    });\n  },\n\n  load<S extends EnvSpec>(spec: S): Pretty<InferEnvSpec<S>> {\n    return resolveNode(\n      '$',\n      spec,\n      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- Empty string -> undefined\n      (key) => process.env[key]?.trim() || undefined,\n    ).getOrElse((errors) => {\n      throw new Error(`Failed to load config: ${errors.join(', ')}`);\n    });\n  },\n};\n\ntype DiscriminatorResult<\n  K extends string,\n  V extends string,\n  M extends Partial<Record<V, Record<string, EnvSpec>>>,\n> = Pretty<\n  // This \"redundant\" condition is necessary to make sure that 'DiscriminatorResult' distributes over\n  // the union type V\n  V extends unknown\n    ? // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- It's used only in an intersection\n      Record<K, V> & InferEnvSpec<M[V] extends EnvSpec ? M[V] : {}>\n    : never\n>;\n\nfunction resolveNode<S extends EnvSpec>(\n  path: string,\n  spec: S,\n  loadValue: (key: string) => string | undefined,\n): ValidationResult<Pretty<InferEnvSpec<S>>> {\n  if (spec instanceof EnvNode) {\n    return (spec as EnvNode<Pretty<InferEnvSpec<S>>>).validate(path, loadValue);\n  }\n\n  return combineValidationResults(\n    ...Object.entries(spec).map(([key, value]) =>\n      resolveNode(`${path}.${key}`, value, loadValue).map(\n        (v) => [key, v] as const,\n      ),\n    ),\n  ).map((entries) => Object.fromEntries(entries) as Pretty<InferEnvSpec<S>>);\n}\n"],"mappings":"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"}

package/dist/if-enabled.d.mts

@@ -0,0 +1,11 @@
+import { EnvNode, EnvSpec, InferEnvSpec } from "./ast.mjs";
+//#region src/if-enabled.d.ts
+type IfEnabled<T> = ({
+  enabled: true;
+} & T) | {
+  enabled: false;
+};
+declare function ifEnabled<T extends Record<string, EnvSpec>>(envVar: string, config: T, defaultEnabled?: boolean): EnvNode<IfEnabled<InferEnvSpec<T>>>;
+//#endregion
+export { ifEnabled };
+//# sourceMappingURL=if-enabled.d.mts.map

package/dist/if-enabled.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"if-enabled.d.mts","names":[],"sources":["../src/if-enabled.ts"],"mappings":";;KAKK,UAAU;EAET;IACE;EACF;;iBAEU,UAAU,UAAU,eAAe,UACjD,gBACA,QAAQ,GACR,2BACC,QAAQ,UAAU,aAAa"}

package/dist/if-enabled.mjs

@@ -0,0 +1,19 @@
+import { env } from "./env.mjs";
+import { Either } from "@prisjakt/utils";
+
+//#region src/if-enabled.ts
+function ifEnabled(envVar, config, defaultEnabled = false) {
+	return env.discriminate("enabled", env.boolean(envVar, defaultEnabled).transform((v) => Either.right(v ? "enabled" : "disabled")), { enabled: config }).transform((value) => {
+		if (value.enabled === "enabled") {
+			return Either.right({
+				...value,
+				enabled: true
+			});
+		}
+		return Either.right({ enabled: false });
+	});
+}
+
+//#endregion
+export { ifEnabled };
+//# sourceMappingURL=if-enabled.mjs.map

package/dist/if-enabled.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"if-enabled.mjs","names":[],"sources":["../src/if-enabled.ts"],"sourcesContent":["import type { ValidationResult } from '@prisjakt/utils';\nimport { Either } from '@prisjakt/utils';\nimport type { EnvNode, EnvSpec, InferEnvSpec } from './ast.js';\nimport { env } from './env.js';\n\ntype IfEnabled<T> =\n  | ({\n      enabled: true;\n    } & T)\n  | { enabled: false };\n\nexport function ifEnabled<T extends Record<string, EnvSpec>>(\n  envVar: string,\n  config: T,\n  defaultEnabled = false,\n): EnvNode<IfEnabled<InferEnvSpec<T>>> {\n  // Since discriminate only works with string values, we need to bridge 'true' -> 'enabled' -> true\n  return env\n    .discriminate(\n      'enabled',\n      env\n        .boolean(envVar, defaultEnabled)\n        .transform((v): ValidationResult<'enabled' | 'disabled'> =>\n          Either.right(v ? 'enabled' : 'disabled'),\n        ),\n      {\n        enabled: config,\n      },\n    )\n    .transform((value): ValidationResult<IfEnabled<InferEnvSpec<T>>> => {\n      if (value.enabled === 'enabled') {\n        return Either.right({\n          ...value,\n          enabled: true,\n        });\n      }\n\n      return Either.right({\n        enabled: false,\n      });\n    });\n}\n"],"mappings":";;;;AAWA,SAAgB,UACd,QACA,QACA,iBAAiB,OACoB;CAErC,OAAO,IACJ,aACC,WACA,IACG,QAAQ,QAAQ,cAAc,CAAC,CAC/B,WAAW,MACV,OAAO,MAAM,IAAI,YAAY,UAAU,CACzC,GACF,EACE,SAAS,OACX,CACF,CAAC,CACA,WAAW,UAAwD;EAClE,IAAI,MAAM,YAAY,WAAW;GAC/B,OAAO,OAAO,MAAM;IAClB,GAAG;IACH,SAAS;GACX,CAAC;EACH;EAEA,OAAO,OAAO,MAAM,EAClB,SAAS,MACX,CAAC;CACH,CAAC;AACL"}

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { EnvNode, EnvSpec, InferEnvSpec } from "./ast.mjs";
+import { env } from "./env.mjs";
+import { ifEnabled } from "./if-enabled.mjs";
+export { type EnvNode, type EnvSpec, type InferEnvSpec, env, ifEnabled };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { env } from "./env.mjs";
+import { ifEnabled } from "./if-enabled.mjs";
+
+export { env, ifEnabled };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@jeengbe/config",
+  "version": "0.0.0",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.spec.ts"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@jeengbe/prelude": "0.0.0"
+  },
+  "devDependencies": {
+    "oxfmt": "^0.60.0",
+    "oxlint": "^1.75.0",
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
+    "@jeengbe/scaffolding": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint": "oxlint --fix . && oxfmt --write .",
+    "test": "vitest",
+    "typecheck": "tsc"
+  }
+}

package/src/ast.ts

@@ -0,0 +1,53 @@
+import type { ValidationResult } from './validation.js';
+import { Either } from '@jeengbe/prelude';
+
+const nodeType = Symbol('type');
+
+export class EnvNode<T> {
+  declare private readonly [nodeType]: T;
+
+  constructor(
+    readonly validate: (
+      path: string,
+      loadValue: (key: string) => string | undefined,
+    ) => ValidationResult<T>,
+  ) {}
+
+  transform<U>(transform: (value: T) => ValidationResult<U>): EnvNode<U> {
+    return new EnvNode((path, loadValue) => this.validate(path, loadValue).flatMap(transform));
+  }
+}
+
+export class ScalarEnvNode<T> extends EnvNode<T> {
+  constructor(
+    readonly key: string,
+    private readonly validateValue: (value: string | undefined) => ValidationResult<T>,
+  ) {
+    super((path, loadValue) => {
+      return validateValue(loadValue(key)).leftMap((errors) =>
+        errors.map((error) => `${key} (${path}): ${error}`),
+      );
+    });
+  }
+
+  optional(): ScalarEnvNode<T | undefined> {
+    return new ScalarEnvNode<T | undefined>(this.key, (value) =>
+      value === undefined ? Either.right(undefined) : this.validateValue(value),
+    );
+  }
+
+  override transform<U>(transform: (value: T) => ValidationResult<U>): ScalarEnvNode<U> {
+    return new ScalarEnvNode(this.key, (value) => this.validateValue(value).flatMap(transform));
+  }
+}
+
+export type EnvSpec = EnvNode<unknown> | { [key: string]: EnvSpec };
+
+export type InferEnvSpec<T extends EnvSpec> =
+  T extends EnvNode<infer U>
+    ? U
+    : T extends Record<string, EnvSpec>
+      ? { [K in keyof T]: InferEnvSpec<T[K]> }
+      : never;
+
+export type Pretty<T> = T extends infer U extends object ? { [K in keyof U]: Pretty<U[K]> } : T;

package/src/env.ts

@@ -0,0 +1,151 @@
+import type { EnvSpec, InferEnvSpec, Pretty } from './ast.js';
+import { EnvNode, ScalarEnvNode } from './ast.js';
+import type { ValidationResult } from './validation.js';
+import { arrayIncludes, combineValidationResults } from './validation.js';
+import { Either } from '@jeengbe/prelude';
+
+export const env = {
+  string(key: string, defaultValue?: string): ScalarEnvNode<string> {
+    return env.custom(key, (value) => Either.right(value), defaultValue);
+  },
+
+  number(key: string, defaultValue?: number): ScalarEnvNode<number> {
+    return env.custom(
+      key,
+      (value) => {
+        if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+          return Either.right(Number(value));
+        }
+
+        return Either.left(['invalid number']);
+      },
+      defaultValue,
+    );
+  },
+
+  boolean(key: string, defaultValue?: boolean): ScalarEnvNode<boolean> {
+    return env.custom(
+      key,
+      (value) => {
+        if (value.toLowerCase() === 'true') return Either.right(true);
+        if (value.toLowerCase() === 'false') return Either.right(false);
+
+        return Either.left(["invalid boolean (must be 'true' or 'false')"]);
+      },
+      defaultValue,
+    );
+  },
+
+  enum<const T extends string>(
+    key: string,
+    values: readonly T[],
+    defaultValue?: T,
+  ): ScalarEnvNode<T> {
+    return env.custom(
+      key,
+      (value) => {
+        if (arrayIncludes(values, value)) return Either.right(value);
+
+        return Either.left([
+          `invalid enum value (must be one of: ${values.map((v) => `'${v}'`).join(', ')})`,
+        ]);
+      },
+      defaultValue,
+    );
+  },
+
+  custom<T>(
+    key: string,
+    transform: (value: string) => ValidationResult<T>,
+    defaultValue?: T,
+  ): ScalarEnvNode<T> {
+    return new ScalarEnvNode(key, (value) => {
+      if (value === undefined) {
+        if (defaultValue !== undefined) return Either.right(defaultValue);
+        return Either.left(['required']);
+      }
+
+      return transform(value);
+    });
+  },
+
+  array<T>(itemType: ScalarEnvNode<T>, defaultValue?: readonly T[]): EnvNode<readonly T[]> {
+    return new EnvNode((path, loadValue) => {
+      const value = loadValue(itemType.key);
+      if (value === undefined) {
+        if (defaultValue !== undefined) return Either.right(defaultValue);
+        return Either.left([`${itemType.key} (${path}): required`]);
+      }
+      if (value === '') return Either.right([]);
+
+      return combineValidationResults(
+        ...value
+          .split(',')
+          .map((v) => v.trim() || undefined)
+          .map((v, i) =>
+            itemType.validate(`${path}.${i}`, (k) => (k === itemType.key ? v : undefined)),
+          ),
+      );
+    });
+  },
+
+  discriminate<
+    K extends string,
+    V extends string,
+    M extends Partial<Record<V, Record<string, EnvSpec>>>,
+  >(
+    discriminatorKey: K,
+    discriminatorValueType: ScalarEnvNode<V>,
+    mapping: M,
+  ): EnvNode<DiscriminatorResult<K, V, M>> {
+    return new EnvNode((path, loadValue) => {
+      return discriminatorValueType.validate(path, loadValue).flatMap((discriminatorValue) => {
+        return resolveNode<NonNullable<M[keyof M]> | {}>(
+          path,
+          mapping[discriminatorValue] ?? {},
+          loadValue,
+        ).map(
+          (mappingValues) =>
+            ({
+              [discriminatorKey]: discriminatorValue,
+              ...mappingValues,
+            }) as DiscriminatorResult<K, V, M>,
+        );
+      });
+    });
+  },
+
+  load<S extends EnvSpec>(spec: S): Pretty<InferEnvSpec<S>> {
+    return resolveNode('$', spec, (key) => process.env[key]?.trim() || undefined).getOrElse(
+      (errors) => {
+        throw new Error(`Failed to load config: ${errors.join(', ')}`);
+      },
+    );
+  },
+};
+
+type DiscriminatorResult<
+  K extends string,
+  V extends string,
+  M extends Partial<Record<V, Record<string, EnvSpec>>>,
+> = Pretty<
+  // This "redundant" condition is necessary to make sure that 'DiscriminatorResult' distributes over
+  // the union type V
+  V extends unknown ? Record<K, V> & InferEnvSpec<M[V] extends EnvSpec ? M[V] : {}> : never
+>;
+
+function resolveNode<S extends EnvSpec>(
+  path: string,
+  spec: S,
+  loadValue: (key: string) => string | undefined,
+): ValidationResult<Pretty<InferEnvSpec<S>>> {
+  if (spec instanceof EnvNode) {
+    return (spec as EnvNode<Pretty<InferEnvSpec<S>>>).validate(path, loadValue);
+  }
+
+  return combineValidationResults(
+    ...Object.entries(spec).map(([key, value]) =>
+      resolveNode(`${path}.${key}`, value, loadValue).map((v) => [key, v] as const),
+    ),
+  ).map((entries) => Object.fromEntries(entries) as Pretty<InferEnvSpec<S>>);
+}

package/src/if-enabled.ts

@@ -0,0 +1,42 @@
+import type { EnvNode, EnvSpec, InferEnvSpec } from './ast.js';
+import { env } from './env.js';
+import type { ValidationResult } from './validation.js';
+import { Either } from '@jeengbe/prelude';
+
+type IfEnabled<T> =
+  | ({
+      enabled: true;
+    } & T)
+  | { enabled: false };
+
+export function ifEnabled<T extends Record<string, EnvSpec>>(
+  envVar: string,
+  config: T,
+  defaultEnabled = false,
+): EnvNode<IfEnabled<InferEnvSpec<T>>> {
+  // Since discriminate only works with string values, we need to bridge 'true' -> 'enabled' -> true
+  return env
+    .discriminate(
+      'enabled',
+      env
+        .boolean(envVar, defaultEnabled)
+        .transform(
+          (v): ValidationResult<'enabled' | 'disabled'> => Either.right(v ? 'enabled' : 'disabled'),
+        ),
+      {
+        enabled: config,
+      },
+    )
+    .transform((value): ValidationResult<IfEnabled<InferEnvSpec<T>>> => {
+      if (value.enabled === 'enabled') {
+        return Either.right({
+          ...value,
+          enabled: true,
+        });
+      }
+
+      return Either.right({
+        enabled: false,
+      });
+    });
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export type { EnvNode, EnvSpec, InferEnvSpec } from './ast.js';
+export { env } from './env.js';
+export { ifEnabled } from './if-enabled.js';

package/src/validation.ts

@@ -0,0 +1,21 @@
+import { Either } from '@jeengbe/prelude';
+
+export type ValidationResult<T> = Either<readonly string[], T>;
+
+type CombineValidationResult<T extends readonly ValidationResult<unknown>[]> = ValidationResult<{
+  [K in keyof T]: T[K] extends ValidationResult<infer U> ? U : never;
+}>;
+
+export function combineValidationResults<const U extends readonly ValidationResult<unknown>[]>(
+  ...results: U
+): CombineValidationResult<U> {
+  const errors = results.filter((r) => r.isLeft()).flatMap((r) => r.getLeft());
+
+  return errors.length
+    ? Either.left(errors)
+    : (Either.right(results.map((r) => r.get())) as CombineValidationResult<U>);
+}
+
+export function arrayIncludes<const T extends string>(arr: readonly T[], val: unknown): val is T {
+  return arr.includes(val as T);
+}