@buenojs/bueno 0.8.3 → 0.8.5

package/src/cli/utils/fs.ts

@@ -4,8 +4,8 @@
  * Provides file system operations using Bun's native APIs
  */
 
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from "fs";
+import * as path from "path";
 
 /**
  * Check if a file exists
@@ -73,7 +73,7 @@ export async function readFile(filePath: string): Promise<string> {
  * Read a file as string (sync)
  */
 export function readFileSync(filePath: string): string {
-	return fs.readFileSync(filePath, 'utf-8');
+	return fs.readFileSync(filePath, "utf-8");
 }
 
 /**
@@ -98,7 +98,7 @@ export function writeFileSync(filePath: string, content: string): void {
 	const dir = path.dirname(filePath);
 	createDirectorySync(dir);
 
-	fs.writeFileSync(filePath, content, 'utf-8');
+	fs.writeFileSync(filePath, content, "utf-8");
 }
 
 /**
@@ -132,10 +132,7 @@ export function deleteDirectorySync(dirPath: string): void {
 /**
  * Copy a file
  */
-export async function copyFile(
-	src: string,
-	dest: string,
-): Promise<void> {
+export async function copyFile(src: string, dest: string): Promise<void> {
 	// Ensure destination directory exists
 	const dir = path.dirname(dest);
 	await createDirectory(dir);
@@ -211,9 +208,9 @@ export async function findFileUp(
 	options: { stopAt?: string } = {},
 ): Promise<string | null> {
 	let currentDir = startDir;
-	const stopAt = options.stopAt ?? '/';
+	const stopAt = options.stopAt ?? "/";
 
-	while (currentDir !== stopAt && currentDir !== '/') {
+	while (currentDir !== stopAt && currentDir !== "/") {
 		const filePath = path.join(currentDir, fileName);
 		if (await fileExists(filePath)) {
 			return filePath;
@@ -231,7 +228,7 @@ export async function getProjectRoot(
 	startDir: string = process.cwd(),
 ): Promise<string | null> {
 	// Look for package.json as indicator
-	const packageJsonPath = await findFileUp(startDir, 'package.json');
+	const packageJsonPath = await findFileUp(startDir, "package.json");
 	if (packageJsonPath) {
 		return path.dirname(packageJsonPath);
 	}
@@ -248,10 +245,10 @@ export async function isBuenoProject(
 	if (!root) return false;
 
 	// Check for bueno.config.ts or package.json with bueno dependency
-	const configPath = path.join(root, 'bueno.config.ts');
+	const configPath = path.join(root, "bueno.config.ts");
 	if (await fileExists(configPath)) return true;
 
-	const packageJsonPath = path.join(root, 'package.json');
+	const packageJsonPath = path.join(root, "package.json");
 	if (await fileExists(packageJsonPath)) {
 		const content = await readFile(packageJsonPath);
 		try {
@@ -281,9 +278,10 @@ export async function writeJson(
 	data: unknown,
 	options: { pretty?: boolean } = {},
 ): Promise<void> {
-	const content = options.pretty !== false
-		? JSON.stringify(data, null, 2)
-		: JSON.stringify(data);
+	const content =
+		options.pretty !== false
+			? JSON.stringify(data, null, 2)
+			: JSON.stringify(data);
 	await writeFile(filePath, content);
 }
 
@@ -326,7 +324,7 @@ export function getExtName(filePath: string): string {
  * Normalize path separators
  */
 export function normalizePath(filePath: string): string {
-	return filePath.replace(/\\/g, '/');
+	return filePath.replace(/\\/g, "/");
 }
 
 /**
@@ -339,10 +337,7 @@ export interface TemplateData {
 /**
  * Process a template string
  */
-export function processTemplate(
-	template: string,
-	data: TemplateData,
-): string {
+export function processTemplate(template: string, data: TemplateData): string {
 	let result = template;
 
 	// Process conditionals: {{#if key}}...{{/if}}
@@ -350,7 +345,7 @@ export function processTemplate(
 		/\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g,
 		(_, key: string, content: string) => {
 			const value = data[key];
-			return value ? content : '';
+			return value ? content : "";
 		},
 	);
 
@@ -359,55 +354,74 @@ export function processTemplate(
 		/\{\{#each\s+(\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g,
 		(_, key: string, content: string) => {
 			const items = data[key];
-			if (!Array.isArray(items)) return '';
+			if (!Array.isArray(items)) return "";
 
 			return items
 				.map((item) => {
 					let itemContent = content;
-					if (typeof item === 'object' && item !== null) {
+					if (typeof item === "object" && item !== null) {
 						// Replace nested properties
 						for (const [k, v] of Object.entries(item)) {
 							itemContent = itemContent.replace(
-								new RegExp(`\\{\\{${k}\\}\\}`, 'g'),
+								new RegExp(`\\{\\{${k}\\}\\}`, "g"),
 								String(v),
 							);
 						}
 					}
 					return itemContent;
 				})
-				.join('');
+				.join("");
 		},
 	);
 
 	// Process simple variables with helpers: {{helperName key}}
 	const helpers: Record<string, (v: string) => string> = {
 		camelCase: (v) =>
-			v.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : '')).replace(/^(.)/, (c) => c.toLowerCase()),
+			v
+				.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ""))
+				.replace(/^(.)/, (c) => c.toLowerCase()),
 		pascalCase: (v) =>
-			v.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : '')).replace(/^(.)/, (c) => c.toUpperCase()),
+			v
+				.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ""))
+				.replace(/^(.)/, (c) => c.toUpperCase()),
 		kebabCase: (v) =>
-			v.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[-_\s]+/g, '-').toLowerCase(),
+			v
+				.replace(/([a-z])([A-Z])/g, "$1-$2")
+				.replace(/[-_\s]+/g, "-")
+				.toLowerCase(),
 		snakeCase: (v) =>
-			v.replace(/([a-z])([A-Z])/g, '$1_$2').replace(/[-\s]+/g, '_').toLowerCase(),
+			v
+				.replace(/([a-z])([A-Z])/g, "$1_$2")
+				.replace(/[-\s]+/g, "_")
+				.toLowerCase(),
 		upperCase: (v) => v.toUpperCase(),
 		lowerCase: (v) => v.toLowerCase(),
 		capitalize: (v) => v.charAt(0).toUpperCase() + v.slice(1),
 		pluralize: (v) => {
-			if (v.endsWith('y') && !['ay', 'ey', 'iy', 'oy', 'uy'].some((e) => v.endsWith(e))) {
-				return v.slice(0, -1) + 'ies';
+			if (
+				v.endsWith("y") &&
+				!["ay", "ey", "iy", "oy", "uy"].some((e) => v.endsWith(e))
+			) {
+				return v.slice(0, -1) + "ies";
 			}
-			if (v.endsWith('s') || v.endsWith('x') || v.endsWith('z') || v.endsWith('ch') || v.endsWith('sh')) {
-				return v + 'es';
+			if (
+				v.endsWith("s") ||
+				v.endsWith("x") ||
+				v.endsWith("z") ||
+				v.endsWith("ch") ||
+				v.endsWith("sh")
+			) {
+				return v + "es";
 			}
-			return v + 's';
+			return v + "s";
 		},
 	};
 
 	for (const [helperName, helperFn] of Object.entries(helpers)) {
-		const regex = new RegExp(`\\{\\{${helperName}\\s+(\\w+)\\}\\}`, 'g');
+		const regex = new RegExp(`\\{\\{${helperName}\\s+(\\w+)\\}\\}`, "g");
 		result = result.replace(regex, (_, key: string) => {
 			const value = data[key];
-			if (typeof value === 'string') {
+			if (typeof value === "string") {
 				return helperFn(value);
 			}
 			return String(value);
@@ -416,13 +430,13 @@ export function processTemplate(
 
 	// Process simple variables: {{key}}
 	for (const [key, value] of Object.entries(data)) {
-		const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+		const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
 		result = result.replace(regex, String(value));
 	}
 
 	// Clean up empty lines left by conditionals
-	result = result.replace(/^\s*\n/gm, '\n');
-	result = result.replace(/\n{3,}/g, '\n\n');
+	result = result.replace(/^\s*\n/gm, "\n");
+	result = result.replace(/\n{3,}/g, "\n\n");
 
 	return result.trim();
-}
+}

package/src/cli/utils/index.ts

@@ -4,5 +4,6 @@
  * Re-exports all utility functions
  */
 
-export * from './strings';
-export * from './fs';
+export * from "./strings";
+export * from "./fs";
+export * from "./version";

package/src/cli/utils/strings.ts

@@ -9,7 +9,7 @@
  */
 export function camelCase(str: string): string {
 	return str
-		.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+		.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ""))
 		.replace(/^(.)/, (c) => c.toLowerCase());
 }
 
@@ -18,7 +18,7 @@ export function camelCase(str: string): string {
  */
 export function pascalCase(str: string): string {
 	return str
-		.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+		.replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ""))
 		.replace(/^(.)/, (c) => c.toUpperCase());
 }
 
@@ -27,8 +27,8 @@ export function pascalCase(str: string): string {
  */
 export function kebabCase(str: string): string {
 	return str
-		.replace(/([a-z])([A-Z])/g, '$1-$2')
-		.replace(/[-_\s]+/g, '-')
+		.replace(/([a-z])([A-Z])/g, "$1-$2")
+		.replace(/[-_\s]+/g, "-")
 		.toLowerCase();
 }
 
@@ -37,8 +37,8 @@ export function kebabCase(str: string): string {
  */
 export function snakeCase(str: string): string {
 	return str
-		.replace(/([a-z])([A-Z])/g, '$1_$2')
-		.replace(/[-\s]+/g, '_')
+		.replace(/([a-z])([A-Z])/g, "$1_$2")
+		.replace(/[-\s]+/g, "_")
 		.toLowerCase();
 }
 
@@ -67,31 +67,45 @@ export function capitalize(str: string): string {
  * Pluralize a word (simple implementation)
  */
 export function pluralize(word: string): string {
-	if (word.endsWith('y') && !['ay', 'ey', 'iy', 'oy', 'uy'].some((e) => word.endsWith(e))) {
-		return word.slice(0, -1) + 'ies';
+	if (
+		word.endsWith("y") &&
+		!["ay", "ey", "iy", "oy", "uy"].some((e) => word.endsWith(e))
+	) {
+		return word.slice(0, -1) + "ies";
 	}
-	if (word.endsWith('s') || word.endsWith('x') || word.endsWith('z') || word.endsWith('ch') || word.endsWith('sh')) {
-		return word + 'es';
+	if (
+		word.endsWith("s") ||
+		word.endsWith("x") ||
+		word.endsWith("z") ||
+		word.endsWith("ch") ||
+		word.endsWith("sh")
+	) {
+		return word + "es";
 	}
-	return word + 's';
+	return word + "s";
 }
 
 /**
  * Singularize a word (simple implementation)
  */
 export function singularize(word: string): string {
-	if (word.endsWith('ies')) {
-		return word.slice(0, -3) + 'y';
+	if (word.endsWith("ies")) {
+		return word.slice(0, -3) + "y";
 	}
-	if (word.endsWith('es')) {
+	if (word.endsWith("es")) {
 		// Check for s, x, z, ch, sh endings
 		const withoutEs = word.slice(0, -2);
-		if (withoutEs.endsWith('s') || withoutEs.endsWith('x') || withoutEs.endsWith('z') ||
-			withoutEs.endsWith('ch') || withoutEs.endsWith('sh')) {
+		if (
+			withoutEs.endsWith("s") ||
+			withoutEs.endsWith("x") ||
+			withoutEs.endsWith("z") ||
+			withoutEs.endsWith("ch") ||
+			withoutEs.endsWith("sh")
+		) {
 			return withoutEs;
 		}
 	}
-	if (word.endsWith('s') && !word.endsWith('ss')) {
+	if (word.endsWith("s") && !word.endsWith("ss")) {
 		return word.slice(0, -1);
 	}
 	return word;
@@ -116,13 +130,13 @@ export function isValidFileName(str: string): boolean {
  */
 export function truncate(str: string, maxLength: number): string {
 	if (str.length <= maxLength) return str;
-	return str.slice(0, maxLength - 3) + '...';
+	return str.slice(0, maxLength - 3) + "...";
 }
 
 /**
  * Pad string to center
  */
-export function padCenter(str: string, length: number, char = ' '): string {
+export function padCenter(str: string, length: number, char = " "): string {
 	const padding = length - str.length;
 	if (padding <= 0) return str;
 	const left = Math.floor(padding / 2);
@@ -134,7 +148,7 @@ export function padCenter(str: string, length: number, char = ' '): string {
  * Remove file extension
  */
 export function removeExtension(filename: string): string {
-	const lastDot = filename.lastIndexOf('.');
+	const lastDot = filename.lastIndexOf(".");
 	if (lastDot === -1 || lastDot === 0) return filename;
 	return filename.slice(0, lastDot);
 }
@@ -143,8 +157,8 @@ export function removeExtension(filename: string): string {
  * Get file extension
  */
 export function getExtension(filename: string): string {
-	const lastDot = filename.lastIndexOf('.');
-	if (lastDot === -1 || lastDot === 0) return '';
+	const lastDot = filename.lastIndexOf(".");
+	if (lastDot === -1 || lastDot === 0) return "";
 	return filename.slice(lastDot + 1);
 }
 
@@ -152,8 +166,8 @@ export function getExtension(filename: string): string {
  * Generate a unique ID
  */
 export function generateId(length = 8): string {
-	const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
-	let result = '';
+	const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+	let result = "";
 	for (let i = 0; i < length; i++) {
 		result += chars.charAt(Math.floor(Math.random() * chars.length));
 	}
@@ -164,25 +178,25 @@ export function generateId(length = 8): string {
  * Escape string for use in template literals
  */
 export function escapeTemplateString(str: string): string {
-	return str.replace(/[`\\$]/g, '\\$&');
+	return str.replace(/[`\\$]/g, "\\$&");
 }
 
 /**
  * Escape string for use in regular expressions
  */
 export function escapeRegExp(str: string): string {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 /**
  * Indent a multiline string
  */
 export function indent(str: string, spaces = 2): string {
-	const indentation = ' '.repeat(spaces);
+	const indentation = " ".repeat(spaces);
 	return str
-		.split('\n')
+		.split("\n")
 		.map((line) => (line.trim() ? indentation + line : line))
-		.join('\n');
+		.join("\n");
 }
 
 /**
@@ -190,8 +204,8 @@ export function indent(str: string, spaces = 2): string {
  */
 export function stripLines(str: string): string {
 	return str
-		.split('\n')
+		.split("\n")
 		.map((line) => line.trim())
-		.join('\n')
-		.replace(/\n{3,}/g, '\n\n');
-}
+		.join("\n")
+		.replace(/\n{3,}/g, "\n\n");
+}

package/src/cli/utils/version.ts

@@ -0,0 +1,47 @@
+/**
+ * Version Utility
+ *
+ * Gets the current version of @buenojs/bueno from package.json
+ */
+
+import { readFileSync } from "fs";
+import { join } from "path";
+
+let cachedVersion: string | null = null;
+
+/**
+ * Get the current version of @buenojs/bueno
+ * Reads from package.json at runtime
+ */
+export function getBuenoVersion(): string {
+	if (cachedVersion) {
+		return cachedVersion;
+	}
+
+	try {
+		// Try to read from the package.json in the bueno package
+		const packageJsonPath = join(
+			import.meta.dir,
+			"..",
+			"..",
+			"..",
+			"package.json",
+		);
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+		cachedVersion = `^${packageJson.version}`;
+		return cachedVersion;
+	} catch {
+		// Fallback to a default version if package.json can't be read
+		console.warn("Could not read version from package.json, using default");
+		return "^0.8.0";
+	}
+}
+
+/**
+ * Get the bueno dependency entry for package.json
+ */
+export function getBuenoDependency(): Record<string, string> {
+	return {
+		"@buenojs/bueno": getBuenoVersion(),
+	};
+}

package/src/config/env-validation.ts

@@ -0,0 +1,100 @@
+/**
+ * Environment variable validation for Bueno Framework
+ */
+
+import type { ValidationResult } from "../validation";
+import { validateEnvSync } from "../validation";
+import { envSchema } from "../validation/schemas";
+
+/**
+ * Validate environment variables against the Bueno schema
+ *
+ * @param envVars - Environment variables to validate
+ * @returns Validation result with transformed values or error details
+ */
+export function validateEnvVars(
+	envVars: Record<string, string>,
+): ValidationResult {
+	return validateEnvSync(envSchema, envVars);
+}
+
+/**
+ * Validate and load environment variables from .env files
+ *
+ * @param options - Options for loading and validating environment variables
+ * @returns Validation result with transformed values or error details
+ */
+export async function validateAndLoadEnv(options?: {
+	/** Custom list of env files to load */
+	files?: string[];
+	/** Whether to also load NODE_ENV-specific file */
+	loadNodeEnv?: boolean;
+	/** Base directory for env files */
+	cwd?: string;
+	/** Whether to merge with existing Bun.env */
+	mergeWithProcess?: boolean;
+}): Promise<ValidationResult> {
+	try {
+		// Load environment variables from files
+		const { loadEnvFiles } = await import("./env");
+		const rawEnvVars = await loadEnvFiles(options);
+
+		// Validate the environment variables
+		return validateEnvVars(rawEnvVars);
+	} catch (error) {
+		return {
+			success: false,
+			issues: [
+				{
+					message: `Failed to load and validate environment variables: ${error instanceof Error ? error.message : "Unknown error"}`,
+				},
+			],
+		};
+	}
+}
+
+/**
+ * Get validation error messages as a single string
+ *
+ * @param result - Validation result
+ * @returns Formatted error message or null if valid
+ */
+export function getValidationErrorMessage(
+	result: ValidationResult,
+): string | null {
+	if (result.success) {
+		return null;
+	}
+
+	return result.issues.map((issue) => issue.message).join("\n");
+}
+
+/**
+ * Check if required environment variables are set
+ *
+ * @param envVars - Environment variables to check
+ * @returns True if all required variables are present and valid
+ */
+export function hasRequiredEnvVars(envVars: Record<string, string>): boolean {
+	const result = validateEnvVars(envVars);
+	return result.success;
+}
+
+/**
+ * Get missing required environment variables
+ *
+ * @param envVars - Environment variables to check
+ * @returns Array of missing required variable names
+ */
+export function getMissingEnvVars(envVars: Record<string, string>): string[] {
+	const result = validateEnvVars(envVars);
+	if (result.success) {
+		return [];
+	}
+
+	return result.issues
+		.filter((issue) =>
+			issue.message.includes("This environment variable is required"),
+		)
+		.map((issue) => issue.path?.[0] || "unknown");
+}