@buenojs/bueno 0.8.9 → 0.8.11

package/dist/validation/schemas.d.ts

@@ -0,0 +1,283 @@
+/**
+ * Built-in Schema System
+ * Lightweight validation schema builder for common use cases.
+ * No external dependencies required.
+ */
+import type { StandardResult } from "../types";
+export type FieldValidator = (value: unknown) => {
+    valid: boolean;
+    error?: string;
+    value?: unknown;
+};
+export interface SchemaDefinition {
+    [key: string]: FieldValidator | SchemaDefinition | undefined;
+}
+export declare const Fields: {
+    /**
+     * String field validators
+     */
+    string: (options?: {
+        min?: number;
+        max?: number;
+        pattern?: RegExp;
+        email?: boolean;
+        url?: boolean;
+        uuid?: boolean;
+        optional?: boolean;
+    }) => (value: unknown) => {
+        valid: boolean;
+        value: undefined;
+        error?: undefined;
+    } | {
+        valid: boolean;
+        error: string;
+        value?: undefined;
+    } | {
+        valid: boolean;
+        value: string;
+        error?: undefined;
+    };
+    /**
+     * Number field validators (coerces strings to numbers)
+     */
+    number: (options?: {
+        min?: number;
+        max?: number;
+        integer?: boolean;
+        positive?: boolean;
+        optional?: boolean;
+        default?: number;
+        coerce?: boolean;
+    }) => (value: unknown, validateOnly?: boolean) => {
+        valid: boolean;
+        value: number;
+        error?: undefined;
+    } | {
+        valid: boolean;
+        value: undefined;
+        error?: undefined;
+    } | {
+        valid: boolean;
+        error: string;
+        value?: undefined;
+    };
+    /**
+     * Boolean field validator
+     */
+    boolean: (options?: {
+        optional?: boolean;
+    }) => (value: unknown) => {
+        valid: boolean;
+        value: undefined;
+        error?: undefined;
+    } | {
+        valid: boolean;
+        error: string;
+        value?: undefined;
+    } | {
+        valid: boolean;
+        value: boolean;
+        error?: undefined;
+    };
+    /**
+     * Array field validators
+     */
+    array: (options?: {
+        min?: number;
+        max?: number;
+        itemValidator?: FieldValidator;
+        optional?: boolean;
+    }) => (value: unknown) => {
+        valid: boolean;
+        value: undefined;
+        error?: undefined;
+    } | {
+        valid: boolean;
+        error: string;
+        value?: undefined;
+    } | {
+        valid: boolean;
+        value: any[];
+        error?: undefined;
+    };
+    /**
+     * Enum field validator
+     */
+    enum: (values: readonly (string | number)[], options?: {
+        optional?: boolean;
+    }) => (value: unknown) => {
+        valid: boolean;
+        error: string;
+        value?: undefined;
+    } | {
+        valid: boolean;
+        value: unknown;
+        error?: undefined;
+    };
+    /**
+     * Custom validator function
+     */
+    custom: (validate: (value: unknown) => boolean, message?: string) => (value: unknown) => {
+        valid: boolean;
+        value: unknown;
+        error?: undefined;
+    } | {
+        valid: boolean;
+        error: string;
+        value?: undefined;
+    };
+    /**
+     * Environment variable validators
+     */
+    env: {
+        /**
+         * Required environment variable validator
+         */
+        required: (options?: {
+            optional?: boolean;
+        }) => (value: unknown) => {
+            valid: boolean;
+            value: undefined;
+            error?: undefined;
+        } | {
+            valid: boolean;
+            error: string;
+            value?: undefined;
+        } | {
+            valid: boolean;
+            value: {};
+            error?: undefined;
+        };
+        /**
+         * Port number validator (1-65535)
+         */
+        port: (options?: {
+            optional?: boolean;
+        }) => (value: unknown) => {
+            valid: boolean;
+            value: undefined;
+            error?: undefined;
+        } | {
+            valid: boolean;
+            error: string;
+            value?: undefined;
+        } | {
+            valid: boolean;
+            value: number;
+            error?: undefined;
+        };
+        /**
+         * URL validator
+         */
+        url: (options?: {
+            optional?: boolean;
+        }) => (value: unknown) => {
+            valid: boolean;
+            value: undefined;
+            error?: undefined;
+        } | {
+            valid: boolean;
+            error: string;
+            value?: undefined;
+        } | {
+            valid: boolean;
+            value: string;
+            error?: undefined;
+        };
+        /**
+         * Database URL validator
+         */
+        databaseUrl: (options?: {
+            optional?: boolean;
+        }) => (value: unknown) => {
+            valid: boolean;
+            value: undefined;
+            error?: undefined;
+        } | {
+            valid: boolean;
+            error: string;
+            value?: undefined;
+        } | {
+            valid: boolean;
+            value: string;
+            error?: undefined;
+        };
+        /**
+         * Boolean validator
+         */
+        boolean: (options?: {
+            optional?: boolean;
+        }) => (value: unknown) => {
+            valid: boolean;
+            value: undefined;
+            error?: undefined;
+        } | {
+            valid: boolean;
+            error: string;
+            value?: undefined;
+        } | {
+            valid: boolean;
+            value: boolean;
+            error?: undefined;
+        };
+        /**
+         * Number validator
+         */
+        number: (options?: {
+            min?: number;
+            max?: number;
+            optional?: boolean;
+            integer?: boolean;
+        }) => (value: unknown) => {
+            valid: boolean;
+            value: undefined;
+            error?: undefined;
+        } | {
+            valid: boolean;
+            error: string;
+            value?: undefined;
+        } | {
+            valid: boolean;
+            value: number;
+            error?: undefined;
+        };
+    };
+};
+/**
+ * Built-in schema validator
+ * Simple, zero-dependency schema validation
+ */
+export declare class Schema {
+    private definition;
+    constructor(definition: SchemaDefinition);
+    /**
+     * Create a new schema from field definitions
+     */
+    static object<T extends SchemaDefinition>(definition: T): Schema;
+    /**
+     * Validate data synchronously
+     */
+    validateSync(data: unknown): StandardResult<Record<string, unknown>>;
+    /**
+     * Validate data asynchronously
+     * Currently same as sync, but allows for async validators in future
+     */
+    validate(data: unknown): Promise<StandardResult<Record<string, unknown>>>;
+    /**
+     * Implement Standard Schema interface for compatibility with @buenojs/bueno validators
+     */
+    get ["~standard"](): {
+        validate: (data: unknown) => StandardResult<Record<string, unknown>>;
+        version: number;
+    };
+}
+/**
+ * Create a schema object
+ * Alias for Schema.object() for convenience
+ */
+export declare function schema<T extends SchemaDefinition>(definition: T): Schema;
+/**
+ * Standard environment variable schema for Bueno Framework
+ */
+export declare const envSchema: Schema;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/validation/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/validation/schemas.ts"],"names":[],"mappings":"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"}

package/dist/validation/schemas.js

@@ -0,0 +1,407 @@
+/**
+ * Built-in Schema System
+ * Lightweight validation schema builder for common use cases.
+ * No external dependencies required.
+ */
+// ============= Built-in Field Validators =============
+export const Fields = {
+    /**
+     * String field validators
+     */
+    string: (options = {}) => {
+        return (value) => {
+            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 = {}) => {
+        const shouldCoerce = options.coerce !== false; // Default true
+        return (value, 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 = {}) => {
+        return (value) => {
+            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 = {}) => {
+        return (value) => {
+            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, options = {}) => {
+        return (value) => {
+            if (options.optional && (value === undefined || value === null)) {
+                return { valid: true, value: undefined };
+            }
+            if (!values.includes(value)) {
+                return {
+                    valid: false,
+                    error: `Must be one of: ${values.join(", ")}`,
+                };
+            }
+            return { valid: true, value };
+        };
+    },
+    /**
+     * Custom validator function
+     */
+    custom: (validate, message = "Validation failed") => {
+        return (value) => {
+            if (validate(value)) {
+                return { valid: true, value };
+            }
+            return { valid: false, error: message };
+        };
+    },
+    /**
+     * Environment variable validators
+     */
+    env: {
+        /**
+         * Required environment variable validator
+         */
+        required: (options = {}) => {
+            return (value) => {
+                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 = {}) => {
+            return (value) => {
+                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 = {}) => {
+            return (value) => {
+                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 = {}) => {
+            return (value) => {
+                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 = {}) => {
+            return (value) => {
+                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 = {}) => {
+            return (value) => {
+                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 {
+    definition;
+    constructor(definition) {
+        this.definition = definition;
+    }
+    /**
+     * Create a new schema from field definitions
+     */
+    static object(definition) {
+        return new Schema(definition);
+    }
+    /**
+     * Validate data synchronously
+     */
+    validateSync(data) {
+        const errors = [];
+        const validated = {};
+        if (typeof data !== "object" || data === null) {
+            return {
+                issues: [{ message: "Input must be an object" }],
+            };
+        }
+        const obj = data;
+        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) {
+        return this.validateSync(data);
+    }
+    /**
+     * Implement Standard Schema interface for compatibility with @buenojs/bueno validators
+     */
+    get ["~standard"]() {
+        return {
+            validate: (data) => this.validateSync(data),
+            version: 1,
+        };
+    }
+}
+/**
+ * Create a schema object
+ * Alias for Schema.object() for convenience
+ */
+export function schema(definition) {
+    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 }),
+});
+//# sourceMappingURL=schemas.js.map