@bintvn/lite-env 1.0.0

package/README.md

@@ -0,0 +1,192 @@
+# lite-env
+
+`lite-env` is a small TypeScript-first environment loader for Node.js. It reads `.env` and `.env.{NODE_ENV}`, merges them, parses values into runtime types, and returns a type-safe object inferred from your schema.
+
+## Features
+
+- Loads `.env` and `.env.{NODE_ENV}`
+- Infers the return type from the schema you pass to `loadEnv`
+- Parses common value types: `string`, `number`, `boolean`, `array`, `object`, `buffer`, and `date`
+- Can optionally reject unknown keys in your env files
+- Stores the parsed result in a global cache to avoid reloading
+
+## Installation
+
+```bash
+npm install lite-env
+```
+
+## Quick Start
+
+Create your env files:
+
+```env
+# .env
+APP_NAME=lite-env
+PORT=3000
+DEBUG=false
+```
+
+```env
+# .env.development
+DEBUG=true
+TAGS=api,dev,local
+```
+
+Use `loadEnv` in your app:
+
+```ts
+import { loadEnv } from 'lite-env'
+
+const env = loadEnv({
+  APP_NAME: 'string',
+  PORT: 'number',
+  DEBUG: 'boolean',
+  TAGS: 'array',
+}, true, 'development')
+
+env.APP_NAME
+// string
+
+env.PORT
+// number
+
+env.DEBUG
+// boolean
+
+env.TAGS
+// string[]
+```
+
+## How It Works
+
+`loadEnv` looks for:
+
+- `.env`
+- `.env.{NODE_ENV}`
+
+The values from `.env.{NODE_ENV}` override values from `.env`.
+
+If `NODE_ENV` is not provided:
+
+- it uses `process.env.NODE_ENV` if available
+- otherwise it defaults to `production`
+
+## API
+
+### `loadEnv(schema, bypassUnknownEnvKeys?, NODE_ENV?)`
+
+```ts
+function loadEnv<TSchema extends AllowedEnvKeys = {}>(
+  schema?: TSchema,
+  bypassUnknownEnvKeys?: boolean,
+  NODE_ENV?: string
+): LoadedEnv<TSchema>
+```
+
+#### Parameters
+
+- `schema`: a map of env keys to parser kinds
+- `bypassUnknownEnvKeys`: when `true`, unknown env keys are allowed; when `false`, unknown keys throw an error
+- `NODE_ENV`: optional environment name used to resolve `.env.{NODE_ENV}`
+
+#### Return Value
+
+Returns a parsed object with types inferred from the schema.
+
+Example:
+
+```ts
+const env = loadEnv({
+  PORT: 'number',
+  ENABLE_LOGS: 'boolean',
+  START_DATE: 'date',
+})
+
+// inferred type:
+// {
+//   PORT: number
+//   ENABLE_LOGS: boolean
+//   START_DATE: Date
+// }
+```
+
+## Supported Types
+
+`lite-env` currently supports the following schema kinds:
+
+| Schema value | Result type | Notes |
+| --- | --- | --- |
+| `string` | `string` | Raw string |
+| `number` | `number` | Uses `Number(value)` |
+| `boolean` | `boolean` | Accepts `true`, `false`, `1`, `0` |
+| `array` | `string[]` | Splits by comma |
+| `object` | `unknown` | Uses `JSON.parse` |
+| `buffer` | `Buffer` | Uses `Buffer.from(value, 'base64')` |
+| `date` | `Date` | Uses `new Date(value)` |
+
+## Type Inference
+
+The main goal of `lite-env` is type-safe inference from the input schema.
+
+```ts
+const env = loadEnv({
+  DB_HOST: 'string',
+  DB_PORT: 'number',
+  DB_SSL: 'boolean',
+})
+```
+
+TypeScript infers:
+
+```ts
+{
+  DB_HOST: string
+  DB_PORT: number
+  DB_SSL: boolean
+}
+```
+
+`object` currently resolves to `unknown` on purpose, so the public API stays simple.
+
+## Unknown Key Behavior
+
+By default, `bypassUnknownEnvKeys` is `true`.
+
+That means:
+
+- extra keys in your env files are allowed
+- raw merged env values are copied into `process.env`
+
+If you want strict validation, pass `false`:
+
+```ts
+const env = loadEnv({
+  PORT: 'number',
+  DEBUG: 'boolean',
+}, false)
+```
+
+In strict mode, any key found in the env files but not declared in the schema will throw an error.
+
+## Notes
+
+- Parsed results are cached in `globalThis.liteEnv`
+- If you call `loadEnv()` multiple times with different schemas in the same runtime, the cached result is reused
+- Missing declared keys are currently skipped instead of throwing
+- `.env` must exist
+- `.env.{NODE_ENV}` must also exist
+
+## Example Project Structure
+
+```txt
+your-project/
+├─ .env
+├─ .env.development
+├─ src/
+│  └─ index.ts
+```
+
+## License
+
+ISC

package/dist/index.cjs

@@ -0,0 +1,200 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  loadEnv: () => loadEnv
+});
+module.exports = __toCommonJS(index_exports);
+var import_path = __toESM(require("path"), 1);
+var import_fs2 = require("fs");
+
+// src/helper.ts
+var import_fs = require("fs");
+function toString(value) {
+  return String(value);
+}
+function toNumber(value) {
+  const parsed = Number(value);
+  if (Number.isNaN(parsed))
+    throw new Error("Value is not supported for number");
+  return parsed;
+}
+function toArray(value) {
+  if (!value.includes(","))
+    throw new Error("Valur is not supported for array");
+  return value.split(",");
+}
+function toBoolean(value) {
+  if (value === "true" || value === "1")
+    return true;
+  if (value === "false" || value === "0")
+    return false;
+  throw new Error("Value is not supported for boolean");
+}
+function toObject(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error("Value is not supported for object");
+  }
+}
+function toBuffer(value, encoding) {
+  try {
+    return Buffer.from(value, encoding || "base64");
+  } catch (error) {
+    throw new Error("Value is not supported for buffer");
+  }
+}
+function toDate(value) {
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime()))
+    throw new Error("Value is not supported for date");
+  return parsed;
+}
+function parseEnvValue(kind, value) {
+  switch (kind) {
+    case "string":
+      return toString(value);
+    case "number":
+      return toNumber(value);
+    case "boolean":
+      return toBoolean(value);
+    case "array":
+      return toArray(value);
+    case "object":
+      return toObject(value);
+    case "buffer":
+      return toBuffer(value);
+    case "date":
+      return toDate(value);
+    default: {
+      const exhaustiveCheck = kind;
+      throw new Error(`Unsupported env kind: ${exhaustiveCheck}`);
+    }
+  }
+}
+function safeParse(allowedEnvKeys, values) {
+  const data = {};
+  const error = [];
+  for (const key of Object.keys(allowedEnvKeys)) {
+    const value = values[key];
+    if (value === void 0) continue;
+    try {
+      data[key] = parseEnvValue(allowedEnvKeys[key], value);
+    } catch (e) {
+      if (e instanceof Error)
+        error.push(`${String(key)}: ${e.message}`);
+      else
+        error.push(`${String(key)}: Unknown error occurred`);
+    }
+  }
+  return {
+    success: error.length === 0,
+    data,
+    error
+  };
+}
+function formatError(message) {
+  return message.join("\n");
+}
+function parseRawEnv(rawEnv) {
+  const result = {};
+  const lines = rawEnv.split(/\r?\n/);
+  for (const line of lines) {
+    const normalized = line.trim();
+    if (!normalized || normalized.startsWith("#")) continue;
+    const separatorIndex = normalized.indexOf("=");
+    if (separatorIndex <= 0) continue;
+    const key = normalized.slice(0, separatorIndex).trim();
+    const value = normalized.slice(separatorIndex + 1).trim();
+    if (!key) continue;
+    result[key] = value;
+  }
+  return result;
+}
+function readEnvFile(filePath) {
+  if (!(0, import_fs.existsSync)(filePath)) return false;
+  return parseRawEnv((0, import_fs.readFileSync)(filePath, "utf-8"));
+}
+function getUnknownEnvKeys(source, allowedEnvKeys) {
+  return Object.keys(source).filter((key) => !allowedEnvKeys.has(key));
+}
+
+// src/index.ts
+function loadEnv(allowedEnvKeys = {}, bypassUnknownEnvKeys = true, NODE_ENV) {
+  if (globalThis.liteEnv)
+    return globalThis.liteEnv;
+  if (NODE_ENV) {
+    process.env.NODE_ENV = NODE_ENV;
+  } else {
+    if (!process.env.NODE_ENV) {
+      process.env.NODE_ENV = "production";
+    }
+    NODE_ENV = process.env.NODE_ENV;
+  }
+  const defaultEnvPath = import_path.default.join(process.cwd(), ".env");
+  const nodeEnvPath = import_path.default.join(process.cwd(), `.env.${NODE_ENV}`);
+  if (!(0, import_fs2.existsSync)(defaultEnvPath))
+    throw new Error("Default Environment file not found");
+  if (!(0, import_fs2.existsSync)(nodeEnvPath))
+    throw new Error(`Environment file not found: .env.${NODE_ENV}`);
+  const defaultEnvSource = readEnvFile(defaultEnvPath);
+  const nodeEnvSource = readEnvFile(nodeEnvPath);
+  const mergedEnv = {};
+  if (defaultEnvSource)
+    Object.assign(mergedEnv, defaultEnvSource);
+  if (nodeEnvSource)
+    Object.assign(mergedEnv, nodeEnvSource);
+  if (!bypassUnknownEnvKeys) {
+    const unknownKeys = [.../* @__PURE__ */ new Set([...getUnknownEnvKeys(mergedEnv, new Set(Object.keys(allowedEnvKeys)))])];
+    if (unknownKeys.length > 0)
+      throw new Error(`Unknown environment variables in env files: ${unknownKeys.join(", ")}`);
+  } else {
+    process.env = {
+      ...process.env,
+      ...mergedEnv
+    };
+  }
+  const parsedEnv = safeParse(allowedEnvKeys, mergedEnv);
+  if (!parsedEnv.success)
+    throw new Error(`Environment validation failed: ${formatError(parsedEnv.error)}`);
+  globalThis.liteEnv = parsedEnv.data;
+  process.env = {
+    ...process.env,
+    ...parsedEnv.data
+  };
+  console.log("Loaded env file", `${defaultEnvPath}, ${nodeEnvPath}`);
+  return parsedEnv.data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadEnv
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/helper.ts"],"sourcesContent":["import path from 'path'\r\nimport { existsSync } from 'fs'\r\nimport { formatError, getUnknownEnvKeys, readEnvFile, safeParse } from './helper.js'\r\nimport { AllowedEnvKeys, LoadedEnv } from \"./types.js\";\r\n\r\nexport type { AllowedEnvKeys, EnvKind, EnvKindMap, LoadedEnv } from \"./types.js\"\r\n\r\ndeclare global {\r\n    var liteEnv: unknown\r\n}\r\n\r\nexport function loadEnv<TSchema extends AllowedEnvKeys = {}>(\r\n    allowedEnvKeys: TSchema = {} as TSchema,\r\n    bypassUnknownEnvKeys: boolean = true,\r\n    NODE_ENV?: string\r\n): LoadedEnv<TSchema> {\r\n    if (globalThis.liteEnv)\r\n        return globalThis.liteEnv as LoadedEnv<TSchema>\r\n\r\n    if (NODE_ENV) {\r\n        process.env.NODE_ENV = NODE_ENV\r\n    } else {\r\n        if (!process.env.NODE_ENV) {\r\n            process.env.NODE_ENV = 'production'\r\n        }\r\n\r\n        NODE_ENV = process.env.NODE_ENV\r\n    }\r\n\r\n    const defaultEnvPath = path.join(process.cwd(), '.env')\r\n    const nodeEnvPath = path.join(process.cwd(), `.env.${NODE_ENV}`)\r\n\r\n    if (!existsSync(defaultEnvPath))\r\n        throw new Error('Default Environment file not found')\r\n\r\n    if (!existsSync(nodeEnvPath))\r\n        throw new Error(`Environment file not found: .env.${NODE_ENV}`)\r\n\r\n    const defaultEnvSource = readEnvFile(defaultEnvPath)\r\n    const nodeEnvSource = readEnvFile(nodeEnvPath)\r\n\r\n    const mergedEnv: Record<string, string> = {}\r\n\r\n    if (defaultEnvSource)\r\n        Object.assign(mergedEnv, defaultEnvSource)\r\n    if (nodeEnvSource)\r\n        Object.assign(mergedEnv, nodeEnvSource)\r\n\r\n    if (!bypassUnknownEnvKeys) {\r\n        const unknownKeys = [...new Set([...getUnknownEnvKeys(mergedEnv, new Set(Object.keys(allowedEnvKeys)))])]\r\n\r\n        if (unknownKeys.length > 0)\r\n            throw new Error(`Unknown environment variables in env files: ${unknownKeys.join(', ')}`)\r\n    } else {\r\n        process.env = {\r\n            ...process.env,\r\n            ...mergedEnv\r\n        }\r\n    }\r\n\r\n    const parsedEnv = safeParse(allowedEnvKeys, mergedEnv)\r\n\r\n    if (!parsedEnv.success)\r\n        throw new Error(`Environment validation failed: ${formatError(parsedEnv.error)}`)\r\n\r\n    globalThis.liteEnv = parsedEnv.data\r\n\r\n    process.env = {\r\n        ...process.env,\r\n        ...parsedEnv.data\r\n    }\r\n\r\n    console.log('Loaded env file', `${defaultEnvPath}, ${nodeEnvPath}`)\r\n\r\n    return parsedEnv.data as LoadedEnv<TSchema>\r\n}\r\n","import { existsSync, readFileSync } from \"fs\"\nimport { AllowedEnvKeys, EnvKind, EnvKindMap, LoadedEnv } from \"./types.js\"\n\r\nexport function toString(value: string): string {\r\n    return String(value)\r\n}\r\n\r\nexport function toNumber(value: string): number {\n    const parsed = Number(value)\n    if (Number.isNaN(parsed))\n        throw new Error('Value is not supported for number')\n\n    return parsed\n}\n\r\nexport function toArray(value: string): string[] {\r\n    if (!value.includes(','))\r\n        throw new Error('Valur is not supported for array')\r\n\r\n    return value.split(',')\r\n}\r\n\r\nexport function toBoolean(value: string): boolean {\n    if (value === 'true' || value === '1')\n        return true\n\n    if (value === 'false' || value === '0')\n        return false\n\n    throw new Error('Value is not supported for boolean')\n}\n\r\nexport function toObject<T>(value: string): T {\r\n    try {\r\n        return JSON.parse(value)\r\n    } catch (error) {\r\n        throw new Error('Value is not supported for object')\r\n    }\r\n}\r\n\r\nexport function toBuffer(value: string, encoding?: BufferEncoding): Buffer {\r\n    try {\r\n        return Buffer.from(value, encoding || 'base64')\r\n    } catch (error) {\r\n        throw new Error('Value is not supported for buffer')\r\n    }\r\n}\r\n\r\nexport function toDate(value: string): Date {\n    const parsed = new Date(value)\n    if (Number.isNaN(parsed.getTime()))\n        throw new Error('Value is not supported for date')\n\n    return parsed\n}\n\nfunction parseEnvValue<TKind extends EnvKind>(kind: TKind, value: string): EnvKindMap[TKind] {\n    switch (kind) {\n        case \"string\":\n            return toString(value) as EnvKindMap[TKind]\n        case \"number\":\n            return toNumber(value) as EnvKindMap[TKind]\n        case \"boolean\":\n            return toBoolean(value) as EnvKindMap[TKind]\n        case \"array\":\n            return toArray(value) as EnvKindMap[TKind]\n        case \"object\":\n            return toObject(value) as EnvKindMap[TKind]\n        case \"buffer\":\n            return toBuffer(value) as EnvKindMap[TKind]\n        case \"date\":\n            return toDate(value) as EnvKindMap[TKind]\n        default: {\n            const exhaustiveCheck: never = kind\n            throw new Error(`Unsupported env kind: ${exhaustiveCheck}`)\n        }\n    }\n}\n\nexport function safeParse<TSchema extends AllowedEnvKeys>(allowedEnvKeys: TSchema, values: Record<string, string>) {\n    const data: Partial<LoadedEnv<TSchema>> = {}\n    const error: string[] = []\n\n    for (const key of Object.keys(allowedEnvKeys) as Array<keyof TSchema>) {\n        const value = values[key as string]\n        if (value === undefined) continue\n\n        try {\n            data[key] = parseEnvValue(allowedEnvKeys[key], value)\n        } catch (e) {\n            if (e instanceof Error)\n                error.push(`${String(key)}: ${e.message}`)\n            else\n                error.push(`${String(key)}: Unknown error occurred`)\n        }\n    }\n\n    return {\n        success: error.length === 0,\n        data: data as LoadedEnv<TSchema>,\n        error\n    }\n}\n\r\nexport function formatError(message: string[]): string {\r\n    return message.join('\\n')\r\n}\r\n\r\nexport function parseRawEnv(rawEnv: string): Record<string, string> {\r\n    const result: Record<string, string> = {}\r\n    const lines = rawEnv.split(/\\r?\\n/)\r\n\r\n    for (const line of lines) {\r\n        const normalized = line.trim()\r\n        if (!normalized || normalized.startsWith('#')) continue\r\n\r\n        const separatorIndex = normalized.indexOf('=')\r\n        if (separatorIndex <= 0) continue\r\n\r\n        const key = normalized.slice(0, separatorIndex).trim()\r\n        const value = normalized.slice(separatorIndex + 1).trim()\r\n        if (!key) continue\r\n\r\n        result[key] = value\r\n    }\r\n\r\n    return result\r\n}\r\n\r\nexport function readEnvFile(filePath: string): false | Record<string, string> {\r\n    if (!existsSync(filePath)) return false\r\n    return parseRawEnv(readFileSync(filePath, 'utf-8'))\r\n}\r\n\r\nexport function getUnknownEnvKeys(source: Record<string, string>, allowedEnvKeys: Set<string>): string[] {\r\n    return Object.keys(source).filter((key) => !allowedEnvKeys.has(key))\r\n}\r\n"],"mappings":"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","names":["import_fs","path"]}

package/dist/index.d.cts

@@ -0,0 +1,21 @@
+type EnvKindMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    array: string[];
+    object: unknown;
+    buffer: Buffer;
+    date: Date;
+};
+type EnvKind = keyof EnvKindMap;
+type AllowedEnvKeys = Record<string, EnvKind>;
+type LoadedEnv<TSchema extends AllowedEnvKeys> = {
+    [K in keyof TSchema]: EnvKindMap[TSchema[K]];
+};
+
+declare global {
+    var liteEnv: unknown;
+}
+declare function loadEnv<TSchema extends AllowedEnvKeys = {}>(allowedEnvKeys?: TSchema, bypassUnknownEnvKeys?: boolean, NODE_ENV?: string): LoadedEnv<TSchema>;
+
+export { type AllowedEnvKeys, type EnvKind, type EnvKindMap, type LoadedEnv, loadEnv };

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+type EnvKindMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    array: string[];
+    object: unknown;
+    buffer: Buffer;
+    date: Date;
+};
+type EnvKind = keyof EnvKindMap;
+type AllowedEnvKeys = Record<string, EnvKind>;
+type LoadedEnv<TSchema extends AllowedEnvKeys> = {
+    [K in keyof TSchema]: EnvKindMap[TSchema[K]];
+};
+
+declare global {
+    var liteEnv: unknown;
+}
+declare function loadEnv<TSchema extends AllowedEnvKeys = {}>(allowedEnvKeys?: TSchema, bypassUnknownEnvKeys?: boolean, NODE_ENV?: string): LoadedEnv<TSchema>;
+
+export { type AllowedEnvKeys, type EnvKind, type EnvKindMap, type LoadedEnv, loadEnv };

package/dist/index.js

@@ -0,0 +1,166 @@
+// src/index.ts
+import path from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// src/helper.ts
+import { existsSync, readFileSync } from "fs";
+function toString(value) {
+  return String(value);
+}
+function toNumber(value) {
+  const parsed = Number(value);
+  if (Number.isNaN(parsed))
+    throw new Error("Value is not supported for number");
+  return parsed;
+}
+function toArray(value) {
+  if (!value.includes(","))
+    throw new Error("Valur is not supported for array");
+  return value.split(",");
+}
+function toBoolean(value) {
+  if (value === "true" || value === "1")
+    return true;
+  if (value === "false" || value === "0")
+    return false;
+  throw new Error("Value is not supported for boolean");
+}
+function toObject(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error("Value is not supported for object");
+  }
+}
+function toBuffer(value, encoding) {
+  try {
+    return Buffer.from(value, encoding || "base64");
+  } catch (error) {
+    throw new Error("Value is not supported for buffer");
+  }
+}
+function toDate(value) {
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime()))
+    throw new Error("Value is not supported for date");
+  return parsed;
+}
+function parseEnvValue(kind, value) {
+  switch (kind) {
+    case "string":
+      return toString(value);
+    case "number":
+      return toNumber(value);
+    case "boolean":
+      return toBoolean(value);
+    case "array":
+      return toArray(value);
+    case "object":
+      return toObject(value);
+    case "buffer":
+      return toBuffer(value);
+    case "date":
+      return toDate(value);
+    default: {
+      const exhaustiveCheck = kind;
+      throw new Error(`Unsupported env kind: ${exhaustiveCheck}`);
+    }
+  }
+}
+function safeParse(allowedEnvKeys, values) {
+  const data = {};
+  const error = [];
+  for (const key of Object.keys(allowedEnvKeys)) {
+    const value = values[key];
+    if (value === void 0) continue;
+    try {
+      data[key] = parseEnvValue(allowedEnvKeys[key], value);
+    } catch (e) {
+      if (e instanceof Error)
+        error.push(`${String(key)}: ${e.message}`);
+      else
+        error.push(`${String(key)}: Unknown error occurred`);
+    }
+  }
+  return {
+    success: error.length === 0,
+    data,
+    error
+  };
+}
+function formatError(message) {
+  return message.join("\n");
+}
+function parseRawEnv(rawEnv) {
+  const result = {};
+  const lines = rawEnv.split(/\r?\n/);
+  for (const line of lines) {
+    const normalized = line.trim();
+    if (!normalized || normalized.startsWith("#")) continue;
+    const separatorIndex = normalized.indexOf("=");
+    if (separatorIndex <= 0) continue;
+    const key = normalized.slice(0, separatorIndex).trim();
+    const value = normalized.slice(separatorIndex + 1).trim();
+    if (!key) continue;
+    result[key] = value;
+  }
+  return result;
+}
+function readEnvFile(filePath) {
+  if (!existsSync(filePath)) return false;
+  return parseRawEnv(readFileSync(filePath, "utf-8"));
+}
+function getUnknownEnvKeys(source, allowedEnvKeys) {
+  return Object.keys(source).filter((key) => !allowedEnvKeys.has(key));
+}
+
+// src/index.ts
+function loadEnv(allowedEnvKeys = {}, bypassUnknownEnvKeys = true, NODE_ENV) {
+  if (globalThis.liteEnv)
+    return globalThis.liteEnv;
+  if (NODE_ENV) {
+    process.env.NODE_ENV = NODE_ENV;
+  } else {
+    if (!process.env.NODE_ENV) {
+      process.env.NODE_ENV = "production";
+    }
+    NODE_ENV = process.env.NODE_ENV;
+  }
+  const defaultEnvPath = path.join(process.cwd(), ".env");
+  const nodeEnvPath = path.join(process.cwd(), `.env.${NODE_ENV}`);
+  if (!existsSync2(defaultEnvPath))
+    throw new Error("Default Environment file not found");
+  if (!existsSync2(nodeEnvPath))
+    throw new Error(`Environment file not found: .env.${NODE_ENV}`);
+  const defaultEnvSource = readEnvFile(defaultEnvPath);
+  const nodeEnvSource = readEnvFile(nodeEnvPath);
+  const mergedEnv = {};
+  if (defaultEnvSource)
+    Object.assign(mergedEnv, defaultEnvSource);
+  if (nodeEnvSource)
+    Object.assign(mergedEnv, nodeEnvSource);
+  if (!bypassUnknownEnvKeys) {
+    const unknownKeys = [.../* @__PURE__ */ new Set([...getUnknownEnvKeys(mergedEnv, new Set(Object.keys(allowedEnvKeys)))])];
+    if (unknownKeys.length > 0)
+      throw new Error(`Unknown environment variables in env files: ${unknownKeys.join(", ")}`);
+  } else {
+    process.env = {
+      ...process.env,
+      ...mergedEnv
+    };
+  }
+  const parsedEnv = safeParse(allowedEnvKeys, mergedEnv);
+  if (!parsedEnv.success)
+    throw new Error(`Environment validation failed: ${formatError(parsedEnv.error)}`);
+  globalThis.liteEnv = parsedEnv.data;
+  process.env = {
+    ...process.env,
+    ...parsedEnv.data
+  };
+  console.log("Loaded env file", `${defaultEnvPath}, ${nodeEnvPath}`);
+  return parsedEnv.data;
+}
+export {
+  loadEnv
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/helper.ts"],"sourcesContent":["import path from 'path'\r\nimport { existsSync } from 'fs'\r\nimport { formatError, getUnknownEnvKeys, readEnvFile, safeParse } from './helper.js'\r\nimport { AllowedEnvKeys, LoadedEnv } from \"./types.js\";\r\n\r\nexport type { AllowedEnvKeys, EnvKind, EnvKindMap, LoadedEnv } from \"./types.js\"\r\n\r\ndeclare global {\r\n    var liteEnv: unknown\r\n}\r\n\r\nexport function loadEnv<TSchema extends AllowedEnvKeys = {}>(\r\n    allowedEnvKeys: TSchema = {} as TSchema,\r\n    bypassUnknownEnvKeys: boolean = true,\r\n    NODE_ENV?: string\r\n): LoadedEnv<TSchema> {\r\n    if (globalThis.liteEnv)\r\n        return globalThis.liteEnv as LoadedEnv<TSchema>\r\n\r\n    if (NODE_ENV) {\r\n        process.env.NODE_ENV = NODE_ENV\r\n    } else {\r\n        if (!process.env.NODE_ENV) {\r\n            process.env.NODE_ENV = 'production'\r\n        }\r\n\r\n        NODE_ENV = process.env.NODE_ENV\r\n    }\r\n\r\n    const defaultEnvPath = path.join(process.cwd(), '.env')\r\n    const nodeEnvPath = path.join(process.cwd(), `.env.${NODE_ENV}`)\r\n\r\n    if (!existsSync(defaultEnvPath))\r\n        throw new Error('Default Environment file not found')\r\n\r\n    if (!existsSync(nodeEnvPath))\r\n        throw new Error(`Environment file not found: .env.${NODE_ENV}`)\r\n\r\n    const defaultEnvSource = readEnvFile(defaultEnvPath)\r\n    const nodeEnvSource = readEnvFile(nodeEnvPath)\r\n\r\n    const mergedEnv: Record<string, string> = {}\r\n\r\n    if (defaultEnvSource)\r\n        Object.assign(mergedEnv, defaultEnvSource)\r\n    if (nodeEnvSource)\r\n        Object.assign(mergedEnv, nodeEnvSource)\r\n\r\n    if (!bypassUnknownEnvKeys) {\r\n        const unknownKeys = [...new Set([...getUnknownEnvKeys(mergedEnv, new Set(Object.keys(allowedEnvKeys)))])]\r\n\r\n        if (unknownKeys.length > 0)\r\n            throw new Error(`Unknown environment variables in env files: ${unknownKeys.join(', ')}`)\r\n    } else {\r\n        process.env = {\r\n            ...process.env,\r\n            ...mergedEnv\r\n        }\r\n    }\r\n\r\n    const parsedEnv = safeParse(allowedEnvKeys, mergedEnv)\r\n\r\n    if (!parsedEnv.success)\r\n        throw new Error(`Environment validation failed: ${formatError(parsedEnv.error)}`)\r\n\r\n    globalThis.liteEnv = parsedEnv.data\r\n\r\n    process.env = {\r\n        ...process.env,\r\n        ...parsedEnv.data\r\n    }\r\n\r\n    console.log('Loaded env file', `${defaultEnvPath}, ${nodeEnvPath}`)\r\n\r\n    return parsedEnv.data as LoadedEnv<TSchema>\r\n}\r\n","import { existsSync, readFileSync } from \"fs\"\nimport { AllowedEnvKeys, EnvKind, EnvKindMap, LoadedEnv } from \"./types.js\"\n\r\nexport function toString(value: string): string {\r\n    return String(value)\r\n}\r\n\r\nexport function toNumber(value: string): number {\n    const parsed = Number(value)\n    if (Number.isNaN(parsed))\n        throw new Error('Value is not supported for number')\n\n    return parsed\n}\n\r\nexport function toArray(value: string): string[] {\r\n    if (!value.includes(','))\r\n        throw new Error('Valur is not supported for array')\r\n\r\n    return value.split(',')\r\n}\r\n\r\nexport function toBoolean(value: string): boolean {\n    if (value === 'true' || value === '1')\n        return true\n\n    if (value === 'false' || value === '0')\n        return false\n\n    throw new Error('Value is not supported for boolean')\n}\n\r\nexport function toObject<T>(value: string): T {\r\n    try {\r\n        return JSON.parse(value)\r\n    } catch (error) {\r\n        throw new Error('Value is not supported for object')\r\n    }\r\n}\r\n\r\nexport function toBuffer(value: string, encoding?: BufferEncoding): Buffer {\r\n    try {\r\n        return Buffer.from(value, encoding || 'base64')\r\n    } catch (error) {\r\n        throw new Error('Value is not supported for buffer')\r\n    }\r\n}\r\n\r\nexport function toDate(value: string): Date {\n    const parsed = new Date(value)\n    if (Number.isNaN(parsed.getTime()))\n        throw new Error('Value is not supported for date')\n\n    return parsed\n}\n\nfunction parseEnvValue<TKind extends EnvKind>(kind: TKind, value: string): EnvKindMap[TKind] {\n    switch (kind) {\n        case \"string\":\n            return toString(value) as EnvKindMap[TKind]\n        case \"number\":\n            return toNumber(value) as EnvKindMap[TKind]\n        case \"boolean\":\n            return toBoolean(value) as EnvKindMap[TKind]\n        case \"array\":\n            return toArray(value) as EnvKindMap[TKind]\n        case \"object\":\n            return toObject(value) as EnvKindMap[TKind]\n        case \"buffer\":\n            return toBuffer(value) as EnvKindMap[TKind]\n        case \"date\":\n            return toDate(value) as EnvKindMap[TKind]\n        default: {\n            const exhaustiveCheck: never = kind\n            throw new Error(`Unsupported env kind: ${exhaustiveCheck}`)\n        }\n    }\n}\n\nexport function safeParse<TSchema extends AllowedEnvKeys>(allowedEnvKeys: TSchema, values: Record<string, string>) {\n    const data: Partial<LoadedEnv<TSchema>> = {}\n    const error: string[] = []\n\n    for (const key of Object.keys(allowedEnvKeys) as Array<keyof TSchema>) {\n        const value = values[key as string]\n        if (value === undefined) continue\n\n        try {\n            data[key] = parseEnvValue(allowedEnvKeys[key], value)\n        } catch (e) {\n            if (e instanceof Error)\n                error.push(`${String(key)}: ${e.message}`)\n            else\n                error.push(`${String(key)}: Unknown error occurred`)\n        }\n    }\n\n    return {\n        success: error.length === 0,\n        data: data as LoadedEnv<TSchema>,\n        error\n    }\n}\n\r\nexport function formatError(message: string[]): string {\r\n    return message.join('\\n')\r\n}\r\n\r\nexport function parseRawEnv(rawEnv: string): Record<string, string> {\r\n    const result: Record<string, string> = {}\r\n    const lines = rawEnv.split(/\\r?\\n/)\r\n\r\n    for (const line of lines) {\r\n        const normalized = line.trim()\r\n        if (!normalized || normalized.startsWith('#')) continue\r\n\r\n        const separatorIndex = normalized.indexOf('=')\r\n        if (separatorIndex <= 0) continue\r\n\r\n        const key = normalized.slice(0, separatorIndex).trim()\r\n        const value = normalized.slice(separatorIndex + 1).trim()\r\n        if (!key) continue\r\n\r\n        result[key] = value\r\n    }\r\n\r\n    return result\r\n}\r\n\r\nexport function readEnvFile(filePath: string): false | Record<string, string> {\r\n    if (!existsSync(filePath)) return false\r\n    return parseRawEnv(readFileSync(filePath, 'utf-8'))\r\n}\r\n\r\nexport function getUnknownEnvKeys(source: Record<string, string>, allowedEnvKeys: Set<string>): string[] {\r\n    return Object.keys(source).filter((key) => !allowedEnvKeys.has(key))\r\n}\r\n"],"mappings":"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","names":["existsSync","existsSync"]}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@bintvn/lite-env",
+  "version": "1.0.0",
+  "description": "TypeScript based environment variable loader.",
+  "keywords": [
+    "util",
+    "helper",
+    "environment",
+    "typescript"
+  ],
+  "license": "ISC",
+  "author": "Bintan <hello@bintvn.co>",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "typecheck": "tsc --noEmit --project tsconfig.json",
+    "prepare": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
+  }
+}

package/src/helper.ts

@@ -0,0 +1,137 @@
+import { existsSync, readFileSync } from "fs"
+import { AllowedEnvKeys, EnvKind, EnvKindMap, LoadedEnv } from "./types.js"
+
+export function toString(value: string): string {
+    return String(value)
+}
+
+export function toNumber(value: string): number {
+    const parsed = Number(value)
+    if (Number.isNaN(parsed))
+        throw new Error('Value is not supported for number')
+
+    return parsed
+}
+
+export function toArray(value: string): string[] {
+    if (!value.includes(','))
+        throw new Error('Valur is not supported for array')
+
+    return value.split(',')
+}
+
+export function toBoolean(value: string): boolean {
+    if (value === 'true' || value === '1')
+        return true
+
+    if (value === 'false' || value === '0')
+        return false
+
+    throw new Error('Value is not supported for boolean')
+}
+
+export function toObject<T>(value: string): T {
+    try {
+        return JSON.parse(value)
+    } catch (error) {
+        throw new Error('Value is not supported for object')
+    }
+}
+
+export function toBuffer(value: string, encoding?: BufferEncoding): Buffer {
+    try {
+        return Buffer.from(value, encoding || 'base64')
+    } catch (error) {
+        throw new Error('Value is not supported for buffer')
+    }
+}
+
+export function toDate(value: string): Date {
+    const parsed = new Date(value)
+    if (Number.isNaN(parsed.getTime()))
+        throw new Error('Value is not supported for date')
+
+    return parsed
+}
+
+function parseEnvValue<TKind extends EnvKind>(kind: TKind, value: string): EnvKindMap[TKind] {
+    switch (kind) {
+        case "string":
+            return toString(value) as EnvKindMap[TKind]
+        case "number":
+            return toNumber(value) as EnvKindMap[TKind]
+        case "boolean":
+            return toBoolean(value) as EnvKindMap[TKind]
+        case "array":
+            return toArray(value) as EnvKindMap[TKind]
+        case "object":
+            return toObject(value) as EnvKindMap[TKind]
+        case "buffer":
+            return toBuffer(value) as EnvKindMap[TKind]
+        case "date":
+            return toDate(value) as EnvKindMap[TKind]
+        default: {
+            const exhaustiveCheck: never = kind
+            throw new Error(`Unsupported env kind: ${exhaustiveCheck}`)
+        }
+    }
+}
+
+export function safeParse<TSchema extends AllowedEnvKeys>(allowedEnvKeys: TSchema, values: Record<string, string>) {
+    const data: Partial<LoadedEnv<TSchema>> = {}
+    const error: string[] = []
+
+    for (const key of Object.keys(allowedEnvKeys) as Array<keyof TSchema>) {
+        const value = values[key as string]
+        if (value === undefined) continue
+
+        try {
+            data[key] = parseEnvValue(allowedEnvKeys[key], value)
+        } catch (e) {
+            if (e instanceof Error)
+                error.push(`${String(key)}: ${e.message}`)
+            else
+                error.push(`${String(key)}: Unknown error occurred`)
+        }
+    }
+
+    return {
+        success: error.length === 0,
+        data: data as LoadedEnv<TSchema>,
+        error
+    }
+}
+
+export function formatError(message: string[]): string {
+    return message.join('\n')
+}
+
+export function parseRawEnv(rawEnv: string): Record<string, string> {
+    const result: Record<string, string> = {}
+    const lines = rawEnv.split(/\r?\n/)
+
+    for (const line of lines) {
+        const normalized = line.trim()
+        if (!normalized || normalized.startsWith('#')) continue
+
+        const separatorIndex = normalized.indexOf('=')
+        if (separatorIndex <= 0) continue
+
+        const key = normalized.slice(0, separatorIndex).trim()
+        const value = normalized.slice(separatorIndex + 1).trim()
+        if (!key) continue
+
+        result[key] = value
+    }
+
+    return result
+}
+
+export function readEnvFile(filePath: string): false | Record<string, string> {
+    if (!existsSync(filePath)) return false
+    return parseRawEnv(readFileSync(filePath, 'utf-8'))
+}
+
+export function getUnknownEnvKeys(source: Record<string, string>, allowedEnvKeys: Set<string>): string[] {
+    return Object.keys(source).filter((key) => !allowedEnvKeys.has(key))
+}

package/src/index.ts

@@ -0,0 +1,76 @@
+import path from 'path'
+import { existsSync } from 'fs'
+import { formatError, getUnknownEnvKeys, readEnvFile, safeParse } from './helper.js'
+import { AllowedEnvKeys, LoadedEnv } from "./types.js";
+
+export type { AllowedEnvKeys, EnvKind, EnvKindMap, LoadedEnv } from "./types.js"
+
+declare global {
+    var liteEnv: unknown
+}
+
+export function loadEnv<TSchema extends AllowedEnvKeys = {}>(
+    allowedEnvKeys: TSchema = {} as TSchema,
+    bypassUnknownEnvKeys: boolean = true,
+    NODE_ENV?: string
+): LoadedEnv<TSchema> {
+    if (globalThis.liteEnv)
+        return globalThis.liteEnv as LoadedEnv<TSchema>
+
+    if (NODE_ENV) {
+        process.env.NODE_ENV = NODE_ENV
+    } else {
+        if (!process.env.NODE_ENV) {
+            process.env.NODE_ENV = 'production'
+        }
+
+        NODE_ENV = process.env.NODE_ENV
+    }
+
+    const defaultEnvPath = path.join(process.cwd(), '.env')
+    const nodeEnvPath = path.join(process.cwd(), `.env.${NODE_ENV}`)
+
+    if (!existsSync(defaultEnvPath))
+        throw new Error('Default Environment file not found')
+
+    if (!existsSync(nodeEnvPath))
+        throw new Error(`Environment file not found: .env.${NODE_ENV}`)
+
+    const defaultEnvSource = readEnvFile(defaultEnvPath)
+    const nodeEnvSource = readEnvFile(nodeEnvPath)
+
+    const mergedEnv: Record<string, string> = {}
+
+    if (defaultEnvSource)
+        Object.assign(mergedEnv, defaultEnvSource)
+    if (nodeEnvSource)
+        Object.assign(mergedEnv, nodeEnvSource)
+
+    if (!bypassUnknownEnvKeys) {
+        const unknownKeys = [...new Set([...getUnknownEnvKeys(mergedEnv, new Set(Object.keys(allowedEnvKeys)))])]
+
+        if (unknownKeys.length > 0)
+            throw new Error(`Unknown environment variables in env files: ${unknownKeys.join(', ')}`)
+    } else {
+        process.env = {
+            ...process.env,
+            ...mergedEnv
+        }
+    }
+
+    const parsedEnv = safeParse(allowedEnvKeys, mergedEnv)
+
+    if (!parsedEnv.success)
+        throw new Error(`Environment validation failed: ${formatError(parsedEnv.error)}`)
+
+    globalThis.liteEnv = parsedEnv.data
+
+    process.env = {
+        ...process.env,
+        ...parsedEnv.data
+    }
+
+    console.log('Loaded env file', `${defaultEnvPath}, ${nodeEnvPath}`)
+
+    return parsedEnv.data as LoadedEnv<TSchema>
+}

package/src/types.ts

@@ -0,0 +1,21 @@
+export type ENV = {
+    NODE_ENV: string
+}
+
+export type EnvKindMap = {
+    string: string
+    number: number
+    boolean: boolean
+    array: string[]
+    object: unknown
+    buffer: Buffer
+    date: Date
+}
+
+export type EnvKind = keyof EnvKindMap
+
+export type AllowedEnvKeys = Record<string, EnvKind>
+
+export type LoadedEnv<TSchema extends AllowedEnvKeys> = {
+    [K in keyof TSchema]: EnvKindMap[TSchema[K]]
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "ignoreDeprecations": "6.0",
+        "rootDir": "src",
+        "outDir": "dist",
+        "tsBuildInfoFile": "./dist/.tsbuildinfo",
+        "types": [
+            "node"
+        ],
+        "noImplicitAny": true,
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "paths": {
+            "@/*": [
+                "./src/*"
+            ]
+        }
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: ['src'],
+    format: ['cjs', 'esm'],
+    dts: true,
+    splitting: false,
+    sourcemap: true,
+    clean: true
+})