@e-n-v/env 0.0.2 → 0.0.4

package/dist/EnvModel-D8rt0EJ6.d.ts

@@ -0,0 +1,134 @@
+import { a as EnumEnvVarSchema, l as EnvVarSchemaBase, r as NumberEnvVarSchema, s as BooleanEnvVarSchema, t as StringEnvVarSchema } from "./StringEnvVarSchema-B8MT7htU.js";
+import { i as EnvVarSchema, n as Preprocessor, t as BooleanMap } from "./BooleanMap-DmFnCA-O.js";
+import { AnySchema } from "joi";
+import { ZodTypeAny } from "zod";
+import { $ZodType } from "zod/v4/core";
+import { Struct } from "superstruct";
+
+//#region ../models/src/schemas.d.ts
+type JoiSchema = AnySchema;
+type ZodV3Schema = ZodTypeAny;
+type ZodV4Schema = $ZodType;
+type SuperstructSchema = Struct<any, any>;
+type Schema = ZodV3Schema | ZodV4Schema | JoiSchema | SuperstructSchema | EnvVarSchema;
+//#endregion
+//#region ../models/src/types.d.ts
+/**
+ * Supported schema types - local definition to avoid circular dependencies
+ */
+type SupportedSchema = Schema;
+type InferZodOutput<T> = T extends {
+  _output: infer Output;
+} ? Output : T extends {
+  _type: infer LegacyOutput;
+} ? LegacyOutput : never;
+type InferJoiOutput<T> = T extends {
+  validate: (...args: any[]) => infer Result;
+} ? Result extends {
+  value: infer Value;
+} ? Value : Result extends Promise<infer AsyncResult> ? AsyncResult extends {
+  value: infer AsyncValue;
+} ? AsyncValue : unknown : unknown : T extends {
+  validateAsync: (...args: any[]) => Promise<infer AsyncValue>;
+} ? AsyncValue : unknown;
+/**
+ * Infer the TypeScript type from an EnvVarSchema instance
+ * Uses the schema's type property and values to determine the correct TypeScript type
+ */
+type InferSchemaType<T> = T extends {
+  readonly type: "string";
+} ? string : T extends {
+  readonly type: "number";
+} ? number : T extends {
+  readonly type: "boolean";
+} ? boolean : T extends {
+  readonly type: "enum";
+  readonly values: readonly (infer U)[];
+} ? U : T extends EnumEnvVarSchema<infer U> ? U : T extends NumberEnvVarSchema ? number : T extends StringEnvVarSchema ? string : T extends BooleanEnvVarSchema ? boolean : T extends EnvVarSchemaBase<infer U> ? U : T extends AnySchema ? InferJoiOutput<T> : T extends ZodTypeAny ? InferZodOutput<T> : T extends $ZodType ? InferZodOutput<T> : unknown;
+/**
+ * Infer whether a schema field is optional based on its required property
+ */
+type InferOptional<T> = T extends {
+  required: false;
+} ? true : T extends {
+  required: true;
+} ? false : T extends {
+  required: boolean;
+} ? boolean : false;
+/**
+ * Utility type to flatten complex generic types for better IDE display
+ */
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * Infer the complete environment type from a schemas record
+ * Handles optional vs required fields properly
+ * Uses Simplify to flatten the type display in IDEs
+ */
+type InferEnvType<T extends Record<string, SupportedSchema>> = Simplify<{ [K in keyof T]: InferOptional<T[K]> extends true ? InferSchemaType<T[K]> | undefined : InferSchemaType<T[K]> }>;
+//#endregion
+//#region ../models/src/EnvModelOptions.d.ts
+type PreprocessorToggle<T> = Preprocessor<T> | boolean | undefined;
+interface Preprocessors {
+  /**
+   * Custom string preprocessing function
+   */
+  string?: PreprocessorToggle<string>;
+  /**
+   * Custom number preprocessing function
+   */
+  number?: PreprocessorToggle<number>;
+  /**
+   * Custom boolean preprocessing function
+   */
+  boolean?: boolean | Preprocessor<boolean> | BooleanMap | undefined;
+  /**
+   * Custom enum preprocessing function
+   */
+  enum?: PreprocessorToggle<string>;
+}
+/**
+ * Options for creating an EnvModel instance
+ */
+interface EnvModelOptions<T extends Record<string, SupportedSchema> = Record<string, SupportedSchema>> {
+  /**
+   * Environment variable schemas
+   * Map of variable names to their schema definitions
+   */
+  schemas: T;
+  /**
+   * Preprocessing configuration
+   * - `true`: Use default preprocessors for all types
+   * - `false`: Disable all preprocessing
+   * - Partial object: Customize specific type preprocessors
+   */
+  preprocess?: true | false | Partial<Preprocessors>;
+}
+//#endregion
+//#region ../models/src/EnvModel.d.ts
+/**
+ * Environment variable specification container
+ * Encapsulates schemas and preprocessor configuration
+ */
+declare class EnvModel<T extends Record<string, SupportedSchema> = Record<string, SupportedSchema>> {
+  /**
+   * Resolved environment variable schemas
+   */
+  readonly schemas: Record<string, EnvVarSchema>;
+  /**
+   * Preprocessing configuration for environment variable types
+   */
+  readonly preprocess: Preprocessors;
+  /**
+   * Create an EnvModel instance from options
+   * @param options - Specification options
+   */
+  constructor(options: EnvModelOptions<T>);
+  /**
+   * Resolve preprocessor configuration from options
+   * @param config - Preprocessor configuration (true, false, or partial object)
+   * @returns Resolved preprocessors object
+   */
+  private resolvePreprocessors;
+}
+//#endregion
+export { SupportedSchema as a, InferSchemaType as i, EnvModelOptions as n, Schema as o, InferEnvType as r, EnvModel as t };

package/dist/EnvSource-BVnmdHku.cjs

@@ -0,0 +1,420 @@
+const require_chunk = require('./chunk-pbleEpgJ.cjs');
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(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 = (0, node_path.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();
+		(0, node_fs.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 node_fs.promises.writeFile(this.filePath, nextContent, "utf8");
+	}
+	readContentSync() {
+		try {
+			return (0, node_fs.readFileSync)(this.filePath, "utf8").replace(/\r\n/g, "\n");
+		} catch (error) {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		}
+	}
+	async readContent() {
+		try {
+			return (await node_fs.promises.readFile(this.filePath, "utf8")).replace(/\r\n/g, "\n");
+		} catch (error) {
+			if (error.code === "ENOENT") return "";
+			throw error;
+		}
+	}
+	ensureDirectorySync() {
+		try {
+			(0, node_fs.mkdirSync)((0, node_path.dirname)(this.filePath), { recursive: true });
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+	async ensureDirectory() {
+		try {
+			await node_fs.promises.mkdir((0, node_path.dirname)(this.filePath), { recursive: true });
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'EnvSource', {
+  enumerable: true,
+  get: function () {
+    return EnvSource;
+  }
+});
+Object.defineProperty(exports, 'get', {
+  enumerable: true,
+  get: function () {
+    return get;
+  }
+});
+Object.defineProperty(exports, 'set', {
+  enumerable: true,
+  get: function () {
+    return set;
+  }
+});