@bintvn/lite-env 1.0.0 → 1.0.2

package/README.md

@@ -1,6 +1,6 @@
-# lite-env
+# @bintvn/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.
+`@bintvn/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
 
@@ -13,7 +13,7 @@
 ## Installation
 
 ```bash
-npm install lite-env
+npm install @bintvn/lite-env
 ```
 
 ## Quick Start
@@ -22,7 +22,7 @@ Create your env files:
 
 ```env
 # .env
-APP_NAME=lite-env
+APP_NAME=@bintvn/lite-env
 PORT=3000
 DEBUG=false
 ```
@@ -36,7 +36,7 @@ TAGS=api,dev,local
 Use `loadEnv` in your app:
 
 ```ts
-import { loadEnv } from 'lite-env'
+import { loadEnv } from '@bintvn/lite-env'
 
 const env = loadEnv({
   APP_NAME: 'string',
@@ -113,7 +113,7 @@ const env = loadEnv({
 
 ## Supported Types
 
-`lite-env` currently supports the following schema kinds:
+`@bintvn/lite-env` currently supports the following schema kinds:
 
 | Schema value | Result type | Notes |
 | --- | --- | --- |
@@ -127,7 +127,7 @@ const env = loadEnv({
 
 ## Type Inference
 
-The main goal of `lite-env` is type-safe inference from the input schema.
+The main goal of `@bintvn/lite-env` is type-safe inference from the input schema.
 
 ```ts
 const env = loadEnv({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bintvn/lite-env",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "TypeScript based environment variable loader.",
   "keywords": [
     "util",
@@ -21,6 +21,9 @@
       "require": "./dist/index.cjs"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts --clean",
     "typecheck": "tsc --noEmit --project tsconfig.json",

package/src/helper.ts

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

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

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

@@ -1,26 +0,0 @@
-{
-    "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

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