@buenojs/bueno 0.8.3 → 0.8.5

package/src/validation/schemas.ts

@@ -0,0 +1,536 @@
+/**
+ * Built-in Schema System
+ * Lightweight validation schema builder for common use cases.
+ * No external dependencies required.
+ */
+
+import type { StandardIssue, StandardResult } from "../types";
+
+// ============= Schema Definition Types =============
+
+export type FieldValidator = (value: unknown) => {
+	valid: boolean;
+	error?: string;
+	value?: unknown; // Coerced/transformed value
+};
+
+export interface SchemaDefinition {
+	[key: string]: FieldValidator | SchemaDefinition | undefined;
+}
+
+// ============= Built-in Field Validators =============
+
+export const Fields = {
+	/**
+	 * String field validators
+	 */
+	string: (
+		options: {
+			min?: number;
+			max?: number;
+			pattern?: RegExp;
+			email?: boolean;
+			url?: boolean;
+			uuid?: boolean;
+			optional?: boolean;
+		} = {},
+	) => {
+		return (value: unknown) => {
+			if (options.optional && (value === undefined || value === null)) {
+				return { valid: true, value: undefined };
+			}
+
+			if (typeof value !== "string") {
+				return { valid: false, error: "Must be a string" };
+			}
+
+			if (options.min !== undefined && value.length < options.min) {
+				return {
+					valid: false,
+					error: `Must be at least ${options.min} characters`,
+				};
+			}
+
+			if (options.max !== undefined && value.length > options.max) {
+				return {
+					valid: false,
+					error: `Must be at most ${options.max} characters`,
+				};
+			}
+
+			if (options.pattern && !options.pattern.test(value)) {
+				return { valid: false, error: "Does not match required pattern" };
+			}
+
+			if (options.email) {
+				const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+				if (!emailRegex.test(value)) {
+					return { valid: false, error: "Must be a valid email address" };
+				}
+			}
+
+			if (options.url) {
+				try {
+					new URL(value);
+				} catch {
+					return { valid: false, error: "Must be a valid URL" };
+				}
+			}
+
+			if (options.uuid) {
+				const uuidRegex =
+					/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+				if (!uuidRegex.test(value)) {
+					return { valid: false, error: "Must be a valid UUID" };
+				}
+			}
+
+			return { valid: true, value };
+		};
+	},
+
+	/**
+	 * Number field validators (coerces strings to numbers)
+	 */
+	number: (
+		options: {
+			min?: number;
+			max?: number;
+			integer?: boolean;
+			positive?: boolean;
+			optional?: boolean;
+			default?: number;
+			coerce?: boolean; // Default: true, coerce strings to numbers
+		} = {},
+	) => {
+		const shouldCoerce = options.coerce !== false; // Default true
+
+		return (value: unknown, validateOnly = false) => {
+			// Apply default if value is missing
+			if (
+				(value === undefined || value === null) &&
+				options.default !== undefined
+			) {
+				return { valid: true, value: options.default };
+			}
+
+			if (options.optional && (value === undefined || value === null)) {
+				return { valid: true, value: undefined };
+			}
+
+			let num = value;
+
+			// Coerce string to number
+			if (shouldCoerce && typeof value === "string") {
+				num = Number(value);
+			}
+
+			if (typeof num !== "number" || Number.isNaN(num)) {
+				return { valid: false, error: "Must be a number" };
+			}
+
+			if (options.integer && !Number.isInteger(num)) {
+				return { valid: false, error: "Must be an integer" };
+			}
+
+			if (options.positive && num <= 0) {
+				return { valid: false, error: "Must be a positive number" };
+			}
+
+			if (options.min !== undefined && num < options.min) {
+				return { valid: false, error: `Must be at least ${options.min}` };
+			}
+
+			if (options.max !== undefined && num > options.max) {
+				return { valid: false, error: `Must be at most ${options.max}` };
+			}
+
+			return { valid: true, value: num };
+		};
+	},
+
+	/**
+	 * Boolean field validator
+	 */
+	boolean: (options: { optional?: boolean } = {}) => {
+		return (value: unknown) => {
+			if (options.optional && (value === undefined || value === null)) {
+				return { valid: true, value: undefined };
+			}
+
+			if (typeof value !== "boolean") {
+				return { valid: false, error: "Must be a boolean" };
+			}
+
+			return { valid: true, value };
+		};
+	},
+
+	/**
+	 * Array field validators
+	 */
+	array: (
+		options: {
+			min?: number;
+			max?: number;
+			itemValidator?: FieldValidator;
+			optional?: boolean;
+		} = {},
+	) => {
+		return (value: unknown) => {
+			if (options.optional && (value === undefined || value === null)) {
+				return { valid: true, value: undefined };
+			}
+
+			if (!Array.isArray(value)) {
+				return { valid: false, error: "Must be an array" };
+			}
+
+			if (options.min !== undefined && value.length < options.min) {
+				return {
+					valid: false,
+					error: `Must have at least ${options.min} items`,
+				};
+			}
+
+			if (options.max !== undefined && value.length > options.max) {
+				return {
+					valid: false,
+					error: `Must have at most ${options.max} items`,
+				};
+			}
+
+			if (options.itemValidator) {
+				for (let i = 0; i < value.length; i++) {
+					const result = options.itemValidator(value[i]);
+					if (!result.valid) {
+						return {
+							valid: false,
+							error: `Item ${i}: ${result.error}`,
+						};
+					}
+				}
+			}
+
+			return { valid: true, value };
+		};
+	},
+
+	/**
+	 * Enum field validator
+	 */
+	enum: (
+		values: readonly (string | number)[],
+		options: { optional?: boolean } = {},
+	) => {
+		return (value: unknown) => {
+			if (options.optional && (value === undefined || value === null)) {
+				return { valid: true, value: undefined };
+			}
+
+			if (!values.includes(value as string | number)) {
+				return {
+					valid: false,
+					error: `Must be one of: ${values.join(", ")}`,
+				};
+			}
+
+			return { valid: true, value };
+		};
+	},
+
+	/**
+	 * Custom validator function
+	 */
+	custom: (
+		validate: (value: unknown) => boolean,
+		message = "Validation failed",
+	) => {
+		return (value: unknown) => {
+			if (validate(value)) {
+				return { valid: true, value };
+			}
+			return { valid: false, error: message };
+		};
+	},
+
+	/**
+	 * Environment variable validators
+	 */
+	env: {
+		/**
+		 * Required environment variable validator
+		 */
+		required: (options: { optional?: boolean } = {}) => {
+			return (value: unknown) => {
+				if (options.optional && (value === undefined || value === null)) {
+					return { valid: true, value: undefined };
+				}
+
+				if (value === undefined || value === null || value === "") {
+					return {
+						valid: false,
+						error: "This environment variable is required",
+					};
+				}
+
+				return { valid: true, value };
+			};
+		},
+
+		/**
+		 * Port number validator (1-65535)
+		 */
+		port: (options: { optional?: boolean } = {}) => {
+			return (value: unknown) => {
+				if (options.optional && (value === undefined || value === null)) {
+					return { valid: true, value: undefined };
+				}
+
+				const num = Number(value);
+				if (isNaN(num) || num < 1 || num > 65535) {
+					return {
+						valid: false,
+						error: "Must be a valid port number (1-65535)",
+					};
+				}
+
+				return { valid: true, value: num };
+			};
+		},
+
+		/**
+		 * URL validator
+		 */
+		url: (options: { optional?: boolean } = {}) => {
+			return (value: unknown) => {
+				if (options.optional && (value === undefined || value === null)) {
+					return { valid: true, value: undefined };
+				}
+
+				if (typeof value !== "string") {
+					return { valid: false, error: "Must be a string" };
+				}
+
+				try {
+					new URL(value);
+					return { valid: true, value };
+				} catch {
+					return { valid: false, error: "Must be a valid URL" };
+				}
+			};
+		},
+
+		/**
+		 * Database URL validator
+		 */
+		databaseUrl: (options: { optional?: boolean } = {}) => {
+			return (value: unknown) => {
+				if (options.optional && (value === undefined || value === null)) {
+					return { valid: true, value: undefined };
+				}
+
+				if (typeof value !== "string") {
+					return { valid: false, error: "Must be a string" };
+				}
+
+				try {
+					const url = new URL(value);
+					const validSchemes = ["postgresql", "mysql", "sqlite", "mongodb"];
+					if (!validSchemes.includes(url.protocol.replace(/:$/, ""))) {
+						return {
+							valid: false,
+							error: `Must be a valid database URL (postgresql://, mysql://, sqlite://, mongodb://)`,
+						};
+					}
+					return { valid: true, value };
+				} catch {
+					return { valid: false, error: "Must be a valid database URL" };
+				}
+			};
+		},
+
+		/**
+		 * Boolean validator
+		 */
+		boolean: (options: { optional?: boolean } = {}) => {
+			return (value: unknown) => {
+				if (options.optional && (value === undefined || value === null)) {
+					return { valid: true, value: undefined };
+				}
+
+				if (
+					typeof value !== "boolean" &&
+					value !== "true" &&
+					value !== "false"
+				) {
+					return { valid: false, error: "Must be a boolean (true/false)" };
+				}
+
+				return { valid: true, value: value === "true" || value === true };
+			};
+		},
+
+		/**
+		 * Number validator
+		 */
+		number: (
+			options: {
+				min?: number;
+				max?: number;
+				optional?: boolean;
+				integer?: boolean;
+			} = {},
+		) => {
+			return (value: unknown) => {
+				if (options.optional && (value === undefined || value === null)) {
+					return { valid: true, value: undefined };
+				}
+
+				const num = Number(value);
+				if (isNaN(num)) {
+					return { valid: false, error: "Must be a number" };
+				}
+
+				if (options.integer && !Number.isInteger(num)) {
+					return { valid: false, error: "Must be an integer" };
+				}
+
+				if (options.min !== undefined && num < options.min) {
+					return { valid: false, error: `Must be at least ${options.min}` };
+				}
+
+				if (options.max !== undefined && num > options.max) {
+					return { valid: false, error: `Must be at most ${options.max}` };
+				}
+
+				return { valid: true, value: num };
+			};
+		},
+	},
+};
+
+// ============= Schema Class =============
+
+/**
+ * Built-in schema validator
+ * Simple, zero-dependency schema validation
+ */
+export class Schema {
+	constructor(private definition: SchemaDefinition) {}
+
+	/**
+	 * Create a new schema from field definitions
+	 */
+	static object<T extends SchemaDefinition>(definition: T): Schema {
+		return new Schema(definition);
+	}
+
+	/**
+	 * Validate data synchronously
+	 */
+	validateSync(data: unknown): StandardResult<Record<string, unknown>> {
+		const errors: StandardIssue[] = [];
+		const validated: Record<string, unknown> = {};
+
+		if (typeof data !== "object" || data === null) {
+			return {
+				issues: [{ message: "Input must be an object" }],
+			};
+		}
+
+		const obj = data as Record<string, unknown>;
+
+		for (const [key, validator] of Object.entries(this.definition)) {
+			if (typeof validator === "function") {
+				const result = validator(obj[key]);
+				if (!result.valid) {
+					errors.push({
+						message: result.error || `Validation failed for ${key}`,
+						path: [key],
+					});
+				} else {
+					// Use coerced value if provided, otherwise use original value
+					validated[key] = result.value !== undefined ? result.value : obj[key];
+				}
+			}
+		}
+
+		if (errors.length > 0) {
+			return { issues: errors };
+		}
+
+		return { value: validated };
+	}
+
+	/**
+	 * Validate data asynchronously
+	 * Currently same as sync, but allows for async validators in future
+	 */
+	async validate(
+		data: unknown,
+	): Promise<StandardResult<Record<string, unknown>>> {
+		return this.validateSync(data);
+	}
+
+	/**
+	 * Implement Standard Schema interface for compatibility with @buenojs/bueno validators
+	 */
+	get ["~standard"]() {
+		return {
+			validate: (data: unknown) => this.validateSync(data),
+			version: 1,
+		};
+	}
+}
+
+/**
+ * Create a schema object
+ * Alias for Schema.object() for convenience
+ */
+export function schema<T extends SchemaDefinition>(definition: T): Schema {
+	return Schema.object(definition);
+}
+
+// ============= Environment Variable Schemas =============
+
+/**
+ * Standard environment variable schema for Bueno Framework
+ */
+export const envSchema = Schema.object({
+	// Required variables
+	NODE_ENV: Fields.env.required(),
+	PORT: Fields.env.port(),
+	HOST: Fields.string({ optional: true }),
+
+	// Database
+	DATABASE_URL: Fields.env.databaseUrl({ optional: true }),
+	DATABASE_POOL_SIZE: Fields.env.number({ min: 1, max: 100, optional: true }),
+
+	// Cache
+	REDIS_URL: Fields.env.url({ optional: true }),
+	CACHE_DRIVER: Fields.enum(["memory", "redis", "none"], { optional: true }),
+	CACHE_TTL: Fields.env.number({ min: 1, optional: true }),
+
+	// Logging
+	LOG_LEVEL: Fields.enum(["error", "warn", "info", "debug", "trace"], {
+		optional: true,
+	}),
+	LOG_PRETTY: Fields.env.boolean({ optional: true }),
+
+	// Health
+	HEALTH_ENABLED: Fields.env.boolean({ optional: true }),
+
+	// Metrics
+	METRICS_ENABLED: Fields.env.boolean({ optional: true }),
+
+	// Telemetry
+	TELEMETRY_ENABLED: Fields.env.boolean({ optional: true }),
+	TELEMETRY_SERVICE_NAME: Fields.string({ optional: true }),
+	TELEMETRY_ENDPOINT: Fields.env.url({ optional: true }),
+
+	// Frontend
+	FRONTEND_DEV_SERVER: Fields.env.boolean({ optional: true }),
+	FRONTEND_HMR: Fields.env.boolean({ optional: true }),
+	FRONTEND_PORT: Fields.env.port({ optional: true }),
+});

package/tests/integration/fullstack.test.ts

@@ -1,5 +1,4 @@
 import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import { z } from 'zod';
 import {
   Router,
   Context,
@@ -11,6 +10,7 @@ import {
   Database,
   createServer,
 } from '../../src';
+import { Schema, Fields } from '../../src/validation/schemas';
 
 // ============= Integration Tests =============
 
@@ -107,9 +107,9 @@ describe('Integration Tests', () => {
 
   describe('Validation Integration', () => {
     test('should validate request body', async () => {
-      const schema = z.object({
-        email: z.string().email(),
-        age: z.number().min(0),
+      const schema = Schema.object({
+        email: Fields.string({ email: true }),
+        age: Fields.number({ min: 0 }),
       });
 
       const validator = createValidator({ body: schema });

package/tests/unit/database.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { Database, detectDriver, createConnection, QueryBuilder, table } from '../../src/database';
+import { Database, detectDriver, createConnection, QueryBuilder } from '../../src/database';
+import { query } from '../../src/database/orm/builder';
 
 describe('Database', () => {
   // Use SQLite for testing (no external dependencies)
@@ -102,77 +103,6 @@ describe('Database', () => {
     });
   });
 
-  describe('QueryBuilder', () => {
-    let db: Database;
-    let users: QueryBuilder<{ id: number; name: string; email: string }>;
-
-    beforeEach(async () => {
-      db = new Database({ url: testDbPath });
-      await db.connect();
-      
-      await db.raw(`
-        CREATE TABLE IF NOT EXISTS users (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          name TEXT NOT NULL,
-          email TEXT UNIQUE
-        )
-      `);
-      
-      users = table<{ id: number; name: string; email: string }>(db, 'users');
-    });
-
-    afterEach(async () => {
-      await db.close();
-    });
-
-    test('should insert and find by id', async () => {
-      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
-      expect(inserted.name).toBe('John');
-      
-      const found = await users.findById(inserted.id);
-      expect(found?.name).toBe('John');
-    });
-
-    test('should count rows', async () => {
-      await users.insert({ name: 'John', email: 'john@example.com' });
-      await users.insert({ name: 'Jane', email: 'jane@example.com' });
-      
-      const count = await users.count();
-      expect(count).toBe(2);
-    });
-
-    test('should delete by id', async () => {
-      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
-      
-      const deleted = await users.deleteById(inserted.id);
-      expect(deleted).toBe(true);
-      
-      const found = await users.findById(inserted.id);
-      expect(found).toBeNull();
-    });
-
-    test('should update by id', async () => {
-      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
-      
-      const updated = await users.updateById(inserted.id, { name: 'Johnny' });
-      expect(updated?.name).toBe('Johnny');
-    });
-
-    test('should paginate results', async () => {
-      for (let i = 0; i < 25; i++) {
-        await users.insert({ name: `User${i}`, email: `user${i}@example.com` });
-      }
-      
-      const page1 = await users.paginate(1, 10);
-      expect(page1.data.length).toBe(10);
-      expect(page1.total).toBe(25);
-      expect(page1.totalPages).toBe(3);
-      
-      const page3 = await users.paginate(3, 10);
-      expect(page3.data.length).toBe(5);
-    });
-  });
-
   describe('createConnection', () => {
     test('should create and connect to database', async () => {
       const db = await createConnection({ url: ':memory:' });