@e-n-v/env 0.0.1 → 0.0.4

package/dist/EnvSource-DA3ZGlES.js

@@ -0,0 +1,400 @@
+import { mkdirSync, promises, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+//#region ../files/src/utils.ts
+function normalizeContent(content) {
+	return content.replace(/\r\n/g, "\n");
+}
+function splitLines(content) {
+	return content === "" ? [] : content.split("\n");
+}
+function validateKey(key) {
+	const trimmed = key.trim();
+	if (!trimmed) throw new TypeError("Environment variable name cannot be empty");
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed)) throw new TypeError(`Invalid environment variable name: ${trimmed}`);
+	return trimmed;
+}
+function parseAssignmentEndingAt(lines, endIndex) {
+	const lastLine = lines[endIndex];
+	if (typeof lastLine !== "string" || isSkippableLine(lastLine)) return null;
+	const block = [];
+	let start = endIndex;
+	while (start >= 0) {
+		const currentLine = lines[start];
+		if (typeof currentLine !== "string") break;
+		block.unshift(currentLine);
+		if (containsAssignmentOperator(currentLine)) {
+			const parsed = tryParseAssignmentBlock(block);
+			if (!parsed) return null;
+			return {
+				...parsed,
+				startIndex: start,
+				endIndex
+			};
+		}
+		start -= 1;
+	}
+	return null;
+}
+function isSkippableLine(line) {
+	const trimmed = line.trim();
+	return trimmed.length === 0 || trimmed.startsWith("#");
+}
+function containsAssignmentOperator(line) {
+	const trimmed = line.trimStart();
+	if (trimmed.length === 0 || trimmed.startsWith("#")) return false;
+	const commentIndex = trimmed.indexOf("#");
+	return (commentIndex === -1 ? trimmed : trimmed.slice(0, commentIndex)).includes("=");
+}
+function tryParseAssignmentBlock(blockLines) {
+	if (blockLines.length === 0) return null;
+	const firstLine = blockLines[0];
+	const leadingMatch = firstLine.match(/^\s*/);
+	const leading = leadingMatch ? leadingMatch[0] : "";
+	let remainder = firstLine.slice(leading.length);
+	if (remainder.length === 0 || remainder.startsWith("#")) return null;
+	let exportPrefix = "";
+	if (remainder.startsWith("export")) {
+		const afterExport = remainder.slice(6);
+		if (/^\s/.test(afterExport)) {
+			const spacingMatch = afterExport.match(/^\s+/);
+			const spacing = spacingMatch ? spacingMatch[0] : " ";
+			exportPrefix = `export${spacing}`;
+			remainder = afterExport.slice(spacing.length);
+		}
+	}
+	const equalsIndex = remainder.indexOf("=");
+	if (equalsIndex === -1) return null;
+	const key = validateKey(remainder.slice(0, equalsIndex).trim());
+	const parsedValue = parseValueSource([remainder.slice(equalsIndex + 1).replace(/^\s+/, ""), ...blockLines.slice(1)].join("\n"));
+	if (!parsedValue) return null;
+	const trailingTrimmed = parsedValue.trailing.trim();
+	if (trailingTrimmed.length > 0 && !trailingTrimmed.startsWith("#")) return null;
+	return {
+		key,
+		value: parsedValue.value,
+		leading,
+		exportPrefix,
+		trailing: parsedValue.trailing,
+		lines: [...blockLines]
+	};
+}
+function parseValueSource(source) {
+	if (source.length === 0) return {
+		value: "",
+		trailing: ""
+	};
+	const firstChar = source[0];
+	if (firstChar === "\"") return parseDoubleQuotedValue(source);
+	if (firstChar === "'") return parseSingleQuotedValue(source);
+	if (source.includes("\n")) return null;
+	const commentIndex = source.indexOf(" #");
+	const raw = commentIndex === -1 ? source : source.slice(0, commentIndex);
+	const trailing = commentIndex === -1 ? source.slice(raw.length) : source.slice(commentIndex);
+	return {
+		value: raw.trim(),
+		trailing
+	};
+}
+function parseDoubleQuotedValue(source) {
+	let value = "";
+	let escaping = false;
+	for (let i = 1; i < source.length; i += 1) {
+		const char = source[i] ?? "";
+		if (escaping) {
+			switch (char) {
+				case "n":
+					value += "\n";
+					break;
+				case "r":
+					value += "\r";
+					break;
+				case "t":
+					value += "	";
+					break;
+				case "\"":
+					value += "\"";
+					break;
+				case "\\":
+					value += "\\";
+					break;
+				default:
+					value += char;
+					break;
+			}
+			escaping = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (char === "\"") {
+			const trailing = source.slice(i + 1);
+			return {
+				value,
+				trailing
+			};
+		}
+		if (char === "\n") {
+			value += "\n";
+			continue;
+		}
+		value += char;
+	}
+	return null;
+}
+function parseSingleQuotedValue(source) {
+	let value = "";
+	for (let i = 1; i < source.length; i += 1) {
+		const char = source[i] ?? "";
+		if (char === "'") {
+			const trailing = source.slice(i + 1);
+			return {
+				value,
+				trailing
+			};
+		}
+		if (char === "\n") {
+			value += "\n";
+			continue;
+		}
+		value += char;
+	}
+	return null;
+}
+
+//#endregion
+//#region ../files/src/get.ts
+function get(content, arg) {
+	const lines = splitLines(normalizeContent(content));
+	if (typeof arg === "undefined") {
+		const map = scanAll(lines);
+		return Object.fromEntries(map);
+	}
+	if (typeof arg === "string") return scanForSingle(lines, arg);
+	const normalizedTargets = Array.from(new Set(arg.map((name) => validateKey(name))));
+	const lookup = scanForMany(lines, new Set(normalizedTargets));
+	const ordered = normalizedTargets.map((key) => [key, lookup.get(key)]);
+	return Object.fromEntries(ordered);
+}
+function scanAll(lines) {
+	const result = /* @__PURE__ */ new Map();
+	iterateAssignments(lines, (assignment) => {
+		if (!result.has(assignment.key)) result.set(assignment.key, assignment.value);
+	});
+	return result;
+}
+function scanForSingle(lines, target) {
+	const name = validateKey(target);
+	let found;
+	iterateAssignments(lines, (assignment) => {
+		if (assignment.key === name) {
+			found = assignment.value;
+			return true;
+		}
+	});
+	return found;
+}
+function scanForMany(lines, targets) {
+	const normalizedTargets = /* @__PURE__ */ new Set();
+	for (const target of targets) normalizedTargets.add(validateKey(target));
+	const found = /* @__PURE__ */ new Map();
+	const remaining = new Set(normalizedTargets);
+	iterateAssignments(lines, (assignment) => {
+		if (!remaining.has(assignment.key) || found.has(assignment.key)) return;
+		found.set(assignment.key, assignment.value);
+		remaining.delete(assignment.key);
+		if (remaining.size === 0) return true;
+	});
+	return found;
+}
+function iterateAssignments(lines, callback) {
+	for (let i = lines.length - 1; i >= 0;) {
+		const parsed = parseAssignmentEndingAt(lines, i);
+		if (!parsed) {
+			i -= 1;
+			continue;
+		}
+		if (callback(parsed) === true) return;
+		i = parsed.startIndex - 1;
+	}
+}
+
+//#endregion
+//#region ../files/src/set.ts
+function set(content, arg, value) {
+	const normalized = normalizeContent(content);
+	const lines = splitLines(normalized);
+	const entries = normalizeWriteArguments(arg, value);
+	if (entries.length === 0) return ensureTrailingNewline(normalized);
+	const replacements = new Map(entries);
+	const touched = /* @__PURE__ */ new Set();
+	for (let i = lines.length - 1; i >= 0;) {
+		if (replacements.size === 0) break;
+		const parsed = parseAssignmentEndingAt(lines, i);
+		if (!parsed) {
+			i -= 1;
+			continue;
+		}
+		const { key, startIndex, endIndex, leading, exportPrefix, trailing, value: currentValue } = parsed;
+		const nextValue = replacements.get(key);
+		if (typeof nextValue === "undefined" || touched.has(key)) {
+			i = startIndex - 1;
+			continue;
+		}
+		if (nextValue === currentValue) {
+			touched.add(key);
+			replacements.delete(key);
+			i = startIndex - 1;
+			continue;
+		}
+		const block = buildAssignmentLines(key, nextValue, {
+			leading,
+			exportPrefix,
+			trailing
+		});
+		lines.splice(startIndex, endIndex - startIndex + 1, ...block);
+		touched.add(key);
+		replacements.delete(key);
+		i = startIndex - 1;
+	}
+	for (const [key, val] of entries) {
+		if (touched.has(key)) continue;
+		const block = buildAssignmentLines(key, val);
+		const insertIndex = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+		lines.splice(insertIndex, 0, ...block);
+		touched.add(key);
+	}
+	return ensureTrailingNewline(lines.join("\n"));
+}
+function ensureTrailingNewline(content) {
+	if (content.length === 0) return "";
+	if (!content.endsWith("\n")) return `${content}\n`;
+	return content;
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeWriteArguments(arg, value) {
+	if (typeof arg === "string") {
+		if (typeof value === "undefined") throw new TypeError(`Value for variable "${arg}" must be provided`);
+		return [[validateKey(arg), formatValueInput(value)]];
+	}
+	if (!isObjectRecord(arg)) throw new TypeError("Argument must be a string name or an object of key-value pairs");
+	const entries = [];
+	for (const [key, rawValue] of Object.entries(arg)) {
+		if (typeof rawValue === "undefined") throw new TypeError(`Value for variable "${key}" must be provided`);
+		entries.push([validateKey(key), formatValueInput(rawValue)]);
+	}
+	return entries;
+}
+function formatValueInput(value) {
+	if (typeof value === "bigint") return value.toString();
+	return String(value);
+}
+function serializeValue(value) {
+	const normalized = value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	if (!(normalized.length === 0 || /[\s"'\\#]/.test(normalized) || normalized.includes("\n"))) return normalized;
+	let result = "\"";
+	for (const char of normalized) {
+		if (char === "\"") {
+			result += "\\\"";
+			continue;
+		}
+		if (char === "\\") {
+			result += "\\\\";
+			continue;
+		}
+		if (char === "\n") {
+			result += "\n";
+			continue;
+		}
+		result += char;
+	}
+	result += "\"";
+	return result;
+}
+function buildAssignmentLines(key, value, style = {}) {
+	const leading = style.leading ?? "";
+	const exportPrefix = style.exportPrefix ?? "";
+	const trailing = style.trailing ?? "";
+	const segments = serializeValue(value).split("\n");
+	return segments.map((segment, index) => {
+		if (index === 0) return `${leading}${exportPrefix}${key}=${segment}${segments.length === 1 ? trailing : ""}`;
+		if (index === segments.length - 1 && trailing && segments.length > 1) return `${segment}${trailing}`;
+		return segment;
+	});
+}
+
+//#endregion
+//#region ../files/src/EnvSource.ts
+var EnvSource = class {
+	filePath;
+	constructor(filePath) {
+		this.filePath = resolve(process.cwd(), filePath);
+	}
+	readSync(arg) {
+		const content = this.readContentSync();
+		if (typeof arg === "undefined") return get(content);
+		if (typeof arg === "string") return get(content, arg);
+		return get(content, arg);
+	}
+	async read(arg) {
+		const content = await this.readContent();
+		if (typeof arg === "undefined") return get(content);
+		if (typeof arg === "string") return get(content, arg);
+		return get(content, arg);
+	}
+	writeSync(arg, value) {
+		const originalContent = this.readContentSync();
+		let nextContent;
+		if (typeof arg === "string") nextContent = set(originalContent, arg, value);
+		else nextContent = set(originalContent, arg);
+		if (nextContent === originalContent) return;
+		this.ensureDirectorySync();
+		writeFileSync(this.filePath, nextContent, "utf8");
+	}
+	async write(arg, value) {
+		const originalContent = await this.readContent();
+		let nextContent;
+		if (typeof arg === "string") nextContent = set(originalContent, arg, value);
+		else nextContent = set(originalContent, arg);
+		if (nextContent === originalContent) return;
+		await this.ensureDirectory();
+		await promises.writeFile(this.filePath, nextContent, "utf8");
+	}
+	readContentSync() {
+		try {
+			return readFileSync(this.filePath, "utf8").replace(/\r\n/g, "\n");
+		} catch (error) {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		}
+	}
+	async readContent() {
+		try {
+			return (await promises.readFile(this.filePath, "utf8")).replace(/\r\n/g, "\n");
+		} catch (error) {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		}
+	}
+	ensureDirectorySync() {
+		try {
+			mkdirSync(dirname(this.filePath), { recursive: true });
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+	async ensureDirectory() {
+		try {
+			await promises.mkdir(dirname(this.filePath), { recursive: true });
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+};
+
+//#endregion
+export { set as n, get as r, EnvSource as t };

package/dist/ProcessEnvChannel-D465c-dp.d.cts

@@ -0,0 +1,97 @@
+import { c as DotEnvXInstance, o as DotEnvXSetOptions, s as DotEnvXGetOptions, t as EnvChannelOptions } from "./EnvChannelOptions-BPkWDrmr.cjs";
+import { t as EnvChannel } from "./EnvChannel-LMIRYvT1.cjs";
+
+//#region ../channels/src/resolveChannel.d.ts
+
+/**
+ * Resolve channel options into an EnvChannel instance
+ * @param options - The channel options to resolve
+ * @param defaultPath - Default path to use for env files (default: ".env")
+ * @returns An EnvChannel instance
+ */
+declare function resolveChannel(options: EnvChannelOptions, defaultPath?: string): EnvChannel;
+//#endregion
+//#region ../channels/src/channels/default/DefaultEnvChannel.d.ts
+/**
+ * Default implementation of EnvChannel that works with .env files using envrw
+ */
+declare class DefaultEnvChannel implements EnvChannel {
+  private envSource;
+  /**
+   * Create a new DefaultEnvChannel
+   * @param filePath - Path to the .env file to manage
+   */
+  constructor(filePath: string);
+  /**
+   * Get all environment variables
+   * @returns Promise that resolves to object containing all environment variable key-value pairs
+   */
+  get(): Promise<Record<string, string>>;
+  /**
+   * Set multiple environment variables
+   * @param values - Object containing key-value pairs to set
+   * @returns Promise that resolves when the values have been set
+   */
+  set(values: Record<string, string>): Promise<void>;
+}
+//#endregion
+//#region ../channels/src/channels/dotenvx/DotEnvXChannel.d.ts
+/**
+ * Simple DotEnvX implementation of EnvChannel that wraps @dotenvx/dotenvx library
+ * This is just an API mapping wrapper without caching or complex state management
+ */
+declare class DotEnvXChannel implements EnvChannel {
+  private dotenvx;
+  private getOptions;
+  private setOptions;
+  private defaultPath;
+  /**
+   * Create a new DotEnvXChannel
+   * @param dotenvx - The dotenvx instance to use
+   * @param defaultPath - Default path for env files
+   * @param getOptions - Options for get operations
+   * @param setOptions - Options for set operations
+   */
+  constructor(dotenvx: DotEnvXInstance, defaultPath?: string, getOptions?: DotEnvXGetOptions, setOptions?: DotEnvXSetOptions);
+  /**
+   * Get all environment variables
+   * @returns Promise that resolves to object containing all environment variable key-value pairs
+   */
+  get(): Promise<Record<string, string>>;
+  /**
+   * Set multiple environment variables
+   * @param values - Object containing key-value pairs to set
+   * @returns Promise that resolves when the values have been set
+   */
+  set(values: Record<string, string>): Promise<void>;
+  /**
+   * Get the primary path being used for env files
+   * @returns The primary path
+   */
+  getPrimaryPath(): string;
+  /**
+   * Clear any cached data (no-op for this implementation since we don't cache)
+   */
+  clearCache(): void;
+}
+//#endregion
+//#region ../channels/src/channels/processenv/ProcessEnvChannel.d.ts
+/**
+ * EnvChannel implementation that works with process.env
+ * This channel reads from and writes to the current process environment
+ */
+declare class ProcessEnvChannel implements EnvChannel {
+  /**
+   * Get all environment variables from process.env
+   * @returns Promise that resolves to object containing all environment variable key-value pairs
+   */
+  get(): Promise<Record<string, string>>;
+  /**
+   * Set multiple environment variables in process.env
+   * @param values - Object containing key-value pairs to set
+   * @returns Promise that resolves when the values have been set
+   */
+  set(values: Record<string, string>): Promise<void>;
+}
+//#endregion
+export { resolveChannel as i, DotEnvXChannel as n, DefaultEnvChannel as r, ProcessEnvChannel as t };

package/dist/ProcessEnvChannel-Do4-yiLI.d.ts

@@ -0,0 +1,97 @@
+import { c as DotEnvXInstance, o as DotEnvXSetOptions, s as DotEnvXGetOptions, t as EnvChannelOptions } from "./EnvChannelOptions-CRwDLWjd.js";
+import { t as EnvChannel } from "./EnvChannel-w27PEm7x.js";
+
+//#region ../channels/src/resolveChannel.d.ts
+
+/**
+ * Resolve channel options into an EnvChannel instance
+ * @param options - The channel options to resolve
+ * @param defaultPath - Default path to use for env files (default: ".env")
+ * @returns An EnvChannel instance
+ */
+declare function resolveChannel(options: EnvChannelOptions, defaultPath?: string): EnvChannel;
+//#endregion
+//#region ../channels/src/channels/default/DefaultEnvChannel.d.ts
+/**
+ * Default implementation of EnvChannel that works with .env files using envrw
+ */
+declare class DefaultEnvChannel implements EnvChannel {
+  private envSource;
+  /**
+   * Create a new DefaultEnvChannel
+   * @param filePath - Path to the .env file to manage
+   */
+  constructor(filePath: string);
+  /**
+   * Get all environment variables
+   * @returns Promise that resolves to object containing all environment variable key-value pairs
+   */
+  get(): Promise<Record<string, string>>;
+  /**
+   * Set multiple environment variables
+   * @param values - Object containing key-value pairs to set
+   * @returns Promise that resolves when the values have been set
+   */
+  set(values: Record<string, string>): Promise<void>;
+}
+//#endregion
+//#region ../channels/src/channels/dotenvx/DotEnvXChannel.d.ts
+/**
+ * Simple DotEnvX implementation of EnvChannel that wraps @dotenvx/dotenvx library
+ * This is just an API mapping wrapper without caching or complex state management
+ */
+declare class DotEnvXChannel implements EnvChannel {
+  private dotenvx;
+  private getOptions;
+  private setOptions;
+  private defaultPath;
+  /**
+   * Create a new DotEnvXChannel
+   * @param dotenvx - The dotenvx instance to use
+   * @param defaultPath - Default path for env files
+   * @param getOptions - Options for get operations
+   * @param setOptions - Options for set operations
+   */
+  constructor(dotenvx: DotEnvXInstance, defaultPath?: string, getOptions?: DotEnvXGetOptions, setOptions?: DotEnvXSetOptions);
+  /**
+   * Get all environment variables
+   * @returns Promise that resolves to object containing all environment variable key-value pairs
+   */
+  get(): Promise<Record<string, string>>;
+  /**
+   * Set multiple environment variables
+   * @param values - Object containing key-value pairs to set
+   * @returns Promise that resolves when the values have been set
+   */
+  set(values: Record<string, string>): Promise<void>;
+  /**
+   * Get the primary path being used for env files
+   * @returns The primary path
+   */
+  getPrimaryPath(): string;
+  /**
+   * Clear any cached data (no-op for this implementation since we don't cache)
+   */
+  clearCache(): void;
+}
+//#endregion
+//#region ../channels/src/channels/processenv/ProcessEnvChannel.d.ts
+/**
+ * EnvChannel implementation that works with process.env
+ * This channel reads from and writes to the current process environment
+ */
+declare class ProcessEnvChannel implements EnvChannel {
+  /**
+   * Get all environment variables from process.env
+   * @returns Promise that resolves to object containing all environment variable key-value pairs
+   */
+  get(): Promise<Record<string, string>>;
+  /**
+   * Set multiple environment variables in process.env
+   * @param values - Object containing key-value pairs to set
+   * @returns Promise that resolves when the values have been set
+   */
+  set(values: Record<string, string>): Promise<void>;
+}
+//#endregion
+export { resolveChannel as i, DotEnvXChannel as n, DefaultEnvChannel as r, ProcessEnvChannel as t };

package/dist/StringEnvVarSchema-B8MT7htU.d.ts

@@ -0,0 +1,64 @@
+//#region ../core/src/processing/types/Processor.d.ts
+/**
+ * Processor function that transforms a string input to type T.
+ * Returns T if processing succeeds, undefined for empty/null values, throws descriptive errors for invalid values.
+ * Used by environment variable schemas to convert string values to their target types.
+ */
+type Processor<T> = (value: string) => T | undefined;
+//#endregion
+//#region ../core/src/types/EnvVarType.d.ts
+type EnvVarType = "string" | "number" | "boolean" | "enum";
+//#endregion
+//#region ../core/src/schemas/EnvVarSchemaInput.d.ts
+interface EnvVarSchemaInput<T> {
+  process?: Processor<T>;
+  required?: boolean;
+  default?: T;
+  description?: string;
+}
+//#endregion
+//#region ../core/src/schemas/EnvVarSchemaBase.d.ts
+declare abstract class EnvVarSchemaBase<T> {
+  abstract readonly type: EnvVarType;
+  readonly required: boolean;
+  readonly default?: T;
+  readonly description?: string;
+  readonly process: Processor<T>;
+  constructor(input: EnvVarSchemaInput<T>);
+}
+//#endregion
+//#region ../core/src/schemas/typed/BooleanEnvVarSchema.d.ts
+interface BooleanEnvVarSchemaInput extends EnvVarSchemaInput<boolean> {}
+declare class BooleanEnvVarSchema extends EnvVarSchemaBase<boolean> {
+  readonly type: "boolean";
+  constructor(input?: BooleanEnvVarSchemaInput);
+}
+//#endregion
+//#region ../core/src/schemas/typed/EnumEnvVarSchema.d.ts
+interface EnumEnvVarSchemaInput<T extends string = string> extends EnvVarSchemaInput<T> {
+  values: readonly T[];
+}
+declare class EnumEnvVarSchema<T extends string = string> extends EnvVarSchemaBase<T> {
+  readonly type: "enum";
+  readonly values: readonly T[];
+  constructor(input: EnumEnvVarSchemaInput<T>);
+}
+//#endregion
+//#region ../core/src/schemas/typed/NumberEnvVarSchema.d.ts
+interface NumberEnvVarSchemaInput extends EnvVarSchemaInput<number> {}
+declare class NumberEnvVarSchema extends EnvVarSchemaBase<number> {
+  readonly type: "number";
+  constructor(input?: NumberEnvVarSchemaInput);
+}
+//#endregion
+//#region ../core/src/schemas/typed/StringEnvVarSchema.d.ts
+interface StringEnvVarSchemaInput extends EnvVarSchemaInput<string> {
+  secret?: boolean;
+}
+declare class StringEnvVarSchema extends EnvVarSchemaBase<string> {
+  readonly type: "string";
+  readonly secret?: boolean;
+  constructor(input?: StringEnvVarSchemaInput);
+}
+//#endregion
+export { EnumEnvVarSchema as a, BooleanEnvVarSchemaInput as c, EnvVarType as d, Processor as f, NumberEnvVarSchemaInput as i, EnvVarSchemaBase as l, StringEnvVarSchemaInput as n, EnumEnvVarSchemaInput as o, NumberEnvVarSchema as r, BooleanEnvVarSchema as s, StringEnvVarSchema as t, EnvVarSchemaInput as u };