adorn-api 1.0.34 → 1.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adorn-api",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "Decorator-first web framework with OpenAPI 3.1 schema generation.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,7 @@
   },
   "dependencies": {
     "express": "^4.19.2",
-    "metal-orm": "^1.0.94"
+    "metal-orm": "^1.0.104"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.3.15",

package/dist/core/validation.d.ts

@@ -1,10 +0,0 @@
-import type { SchemaSource } from "./schema";
-import { ValidationError } from "./validation-errors";
-/**
- * Validates a value against a schema source.
- * @param value Value to validate
- * @param schema Schema source (schema node or DTO constructor)
- * @param path Optional field path for error reporting
- * @returns Array of validation errors
- */
-export declare function validate(value: unknown, schema: SchemaSource, path?: string): ValidationError[];

package/dist/core/validation.js

@@ -1,533 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = validate;
-const metadata_1 = require("./metadata");
-/**
- * Validates a value against a schema source.
- * @param value Value to validate
- * @param schema Schema source (schema node or DTO constructor)
- * @param path Optional field path for error reporting
- * @returns Array of validation errors
- */
-function validate(value, schema, path = "") {
-    if (typeof schema === "function") {
-        return validateDto(value, schema, path);
-    }
-    return validateSchemaNode(value, schema, path);
-}
-/**
- * Validates a value against a DTO schema.
- * @param value Value to validate
- * @param dto DTO constructor
- * @param path Optional field path for error reporting
- * @returns Array of validation errors
- */
-function validateDto(value, dto, path) {
-    const dtoMeta = (0, metadata_1.getDtoMeta)(dto);
-    if (!dtoMeta) {
-        throw new Error(`DTO "${dto.name}" is missing @Dto decorator.`);
-    }
-    const errors = [];
-    // Check if value is an object
-    if (value === null || value === undefined) {
-        errors.push({
-            field: path,
-            message: "must be an object",
-            value
-        });
-        return errors;
-    }
-    if (typeof value !== "object") {
-        errors.push({
-            field: path,
-            message: "must be an object",
-            value
-        });
-        return errors;
-    }
-    // Validate each field
-    for (const [fieldName, fieldMeta] of Object.entries(dtoMeta.fields)) {
-        const fieldPath = path ? `${path}.${fieldName}` : fieldName;
-        const fieldValue = value[fieldName];
-        const isOptional = fieldMeta.optional ?? fieldMeta.schema.optional ?? false;
-        // Check required field
-        if (!isOptional && fieldValue === undefined) {
-            errors.push({
-                field: fieldPath,
-                message: "is required",
-                value: fieldValue
-            });
-            continue;
-        }
-        // Validate field value if present
-        if (fieldValue !== undefined && fieldValue !== null) {
-            const fieldErrors = validateSchemaNode(fieldValue, fieldMeta.schema, fieldPath);
-            errors.push(...fieldErrors);
-        }
-    }
-    // Check additional properties
-    if (!dtoMeta.additionalProperties) {
-        const valueKeys = Object.keys(value);
-        const dtoKeys = Object.keys(dtoMeta.fields);
-        const additionalKeys = valueKeys.filter(key => !dtoKeys.includes(key));
-        for (const key of additionalKeys) {
-            errors.push({
-                field: path ? `${path}.${key}` : key,
-                message: "is not a valid field",
-                value: value[key]
-            });
-        }
-    }
-    return errors;
-}
-/**
- * Validates a value against a schema node.
- * @param value Value to validate
- * @param schema Schema node to validate against
- * @param path Optional field path for error reporting
- * @returns Array of validation errors
- */
-function validateSchemaNode(value, schema, path) {
-    const errors = [];
-    // Handle optional fields
-    if (schema.optional && value === undefined) {
-        return errors;
-    }
-    // Handle nullable fields
-    if (schema.nullable && value === null) {
-        return errors;
-    }
-    // Validate based on schema kind
-    switch (schema.kind) {
-        case "string":
-            errors.push(...validateString(value, schema, path));
-            break;
-        case "number":
-        case "integer":
-            errors.push(...validateNumber(value, schema, path));
-            break;
-        case "boolean":
-            errors.push(...validateBoolean(value, schema, path));
-            break;
-        case "array":
-            errors.push(...validateArray(value, schema, path));
-            break;
-        case "object":
-            errors.push(...validateObject(value, schema, path));
-            break;
-        case "enum":
-            errors.push(...validateEnum(value, schema, path));
-            break;
-        case "literal":
-            errors.push(...validateLiteral(value, schema, path));
-            break;
-        case "union":
-            errors.push(...validateUnion(value, schema, path));
-            break;
-        case "record":
-            errors.push(...validateRecord(value, schema, path));
-            break;
-        case "ref":
-            errors.push(...validate(value, schema.dto, path));
-            break;
-        case "any":
-            // Any type accepts all values
-            break;
-        case "null":
-            errors.push(...validateNull(value, schema, path));
-            break;
-        case "file":
-            // File validation is handled separately
-            break;
-        default:
-            break;
-    }
-    return errors;
-}
-/**
- * Validates a string value.
- */
-function validateString(value, schema, path) {
-    const errors = [];
-    if (typeof value !== "string") {
-        errors.push({
-            field: path,
-            message: "must be a string",
-            value
-        });
-        return errors;
-    }
-    if (schema.minLength !== undefined && value.length < schema.minLength) {
-        errors.push({
-            field: path,
-            message: `must be at least ${schema.minLength} characters long`,
-            value
-        });
-    }
-    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
-        errors.push({
-            field: path,
-            message: `must be at most ${schema.maxLength} characters long`,
-            value
-        });
-    }
-    if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
-        errors.push({
-            field: path,
-            message: `must match pattern ${schema.pattern}`,
-            value
-        });
-    }
-    if (schema.format) {
-        const formatErrors = validateFormat(value, schema.format, path);
-        errors.push(...formatErrors);
-    }
-    return errors;
-}
-/**
- * Validates string format.
- */
-function validateFormat(value, format, path) {
-    const errors = [];
-    switch (format) {
-        case "uuid":
-            const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-            if (!uuidPattern.test(value)) {
-                errors.push({
-                    field: path,
-                    message: "must be a valid UUID",
-                    value
-                });
-            }
-            break;
-        case "date-time":
-            const date = new Date(value);
-            if (isNaN(date.getTime())) {
-                errors.push({
-                    field: path,
-                    message: "must be a valid date-time",
-                    value
-                });
-            }
-            break;
-    }
-    return errors;
-}
-/**
- * Validates a number value.
- */
-function validateNumber(value, schema, path) {
-    const errors = [];
-    if (typeof value !== "number") {
-        errors.push({
-            field: path,
-            message: `must be a ${schema.kind}`,
-            value
-        });
-        return errors;
-    }
-    if (schema.kind === "integer" && !Number.isInteger(value)) {
-        errors.push({
-            field: path,
-            message: "must be an integer",
-            value
-        });
-    }
-    if (schema.minimum !== undefined && value < schema.minimum) {
-        errors.push({
-            field: path,
-            message: `must be at least ${schema.minimum}`,
-            value
-        });
-    }
-    if (schema.maximum !== undefined && value > schema.maximum) {
-        errors.push({
-            field: path,
-            message: `must be at most ${schema.maximum}`,
-            value
-        });
-    }
-    if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum) {
-        errors.push({
-            field: path,
-            message: `must be greater than ${schema.exclusiveMinimum}`,
-            value
-        });
-    }
-    if (schema.exclusiveMaximum !== undefined && value >= schema.exclusiveMaximum) {
-        errors.push({
-            field: path,
-            message: `must be less than ${schema.exclusiveMaximum}`,
-            value
-        });
-    }
-    if (schema.multipleOf !== undefined && value % schema.multipleOf !== 0) {
-        errors.push({
-            field: path,
-            message: `must be a multiple of ${schema.multipleOf}`,
-            value
-        });
-    }
-    return errors;
-}
-/**
- * Validates a boolean value.
- */
-function validateBoolean(value, schema, path) {
-    const errors = [];
-    if (typeof value !== "boolean") {
-        errors.push({
-            field: path,
-            message: "must be a boolean",
-            value
-        });
-    }
-    return errors;
-}
-/**
- * Validates an array value.
- */
-function validateArray(value, schema, path) {
-    const errors = [];
-    if (!Array.isArray(value)) {
-        errors.push({
-            field: path,
-            message: "must be an array",
-            value
-        });
-        return errors;
-    }
-    if (schema.minItems !== undefined && value.length < schema.minItems) {
-        errors.push({
-            field: path,
-            message: `must have at least ${schema.minItems} items`,
-            value
-        });
-    }
-    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
-        errors.push({
-            field: path,
-            message: `must have at most ${schema.maxItems} items`,
-            value
-        });
-    }
-    if (schema.uniqueItems && hasDuplicates(value)) {
-        errors.push({
-            field: path,
-            message: "must contain unique items",
-            value
-        });
-    }
-    // Validate each item
-    for (let i = 0; i < value.length; i++) {
-        const itemErrors = validateSchemaNode(value[i], schema.items, `${path}[${i}]`);
-        errors.push(...itemErrors);
-    }
-    return errors;
-}
-function hasDuplicates(arr) {
-    const seen = new Set();
-    for (const item of arr) {
-        const serialized = JSON.stringify(item);
-        if (seen.has(serialized)) {
-            return true;
-        }
-        seen.add(serialized);
-    }
-    return false;
-}
-/**
- * Validates an object value.
- */
-function validateObject(value, schema, path) {
-    const errors = [];
-    if (value === null || value === undefined) {
-        errors.push({
-            field: path,
-            message: "must be an object",
-            value
-        });
-        return errors;
-    }
-    if (typeof value !== "object") {
-        errors.push({
-            field: path,
-            message: "must be an object",
-            value
-        });
-        return errors;
-    }
-    if (schema.properties) {
-        // Validate properties
-        for (const [propName, propSchema] of Object.entries(schema.properties)) {
-            const propPath = path ? `${path}.${propName}` : propName;
-            const propValue = value[propName];
-            const isRequired = schema.required?.includes(propName) ?? false;
-            if (isRequired && propValue === undefined) {
-                errors.push({
-                    field: propPath,
-                    message: "is required",
-                    value: propValue
-                });
-                continue;
-            }
-            if (propValue !== undefined && propValue !== null) {
-                const propErrors = validateSchemaNode(propValue, propSchema, propPath);
-                errors.push(...propErrors);
-            }
-        }
-    }
-    // Validate additional properties
-    if (schema.additionalProperties === false) {
-        const valueKeys = Object.keys(value);
-        const schemaKeys = schema.properties ? Object.keys(schema.properties) : [];
-        const additionalKeys = valueKeys.filter(key => !schemaKeys.includes(key));
-        for (const key of additionalKeys) {
-            errors.push({
-                field: path ? `${path}.${key}` : key,
-                message: "is not a valid field",
-                value: value[key]
-            });
-        }
-    }
-    else if (typeof schema.additionalProperties === "object") {
-        const valueKeys = Object.keys(value);
-        const schemaKeys = schema.properties ? Object.keys(schema.properties) : [];
-        const additionalKeys = valueKeys.filter(key => !schemaKeys.includes(key));
-        for (const key of additionalKeys) {
-            const additionalPath = path ? `${path}.${key}` : key;
-            const additionalValue = value[key];
-            const additionalErrors = validateSchemaNode(additionalValue, schema.additionalProperties, additionalPath);
-            errors.push(...additionalErrors);
-        }
-    }
-    if (schema.minProperties !== undefined && Object.keys(value).length < schema.minProperties) {
-        errors.push({
-            field: path,
-            message: `must have at least ${schema.minProperties} properties`,
-            value
-        });
-    }
-    if (schema.maxProperties !== undefined && Object.keys(value).length > schema.maxProperties) {
-        errors.push({
-            field: path,
-            message: `must have at most ${schema.maxProperties} properties`,
-            value
-        });
-    }
-    return errors;
-}
-/**
- * Validates an enum value.
- */
-function validateEnum(value, schema, path) {
-    const errors = [];
-    if (!schema.values.some(v => isEqual(v, value))) {
-        errors.push({
-            field: path,
-            message: `must be one of: ${schema.values.map(v => JSON.stringify(v)).join(", ")}`,
-            value
-        });
-    }
-    return errors;
-}
-/**
- * Validates a literal value.
- */
-function validateLiteral(value, schema, path) {
-    const errors = [];
-    if (!isEqual(schema.value, value)) {
-        errors.push({
-            field: path,
-            message: `must be ${JSON.stringify(schema.value)}`,
-            value
-        });
-    }
-    return errors;
-}
-/**
- * Validates a union value.
- */
-function validateUnion(value, schema, path) {
-    // For union types, value must validate against at least one schema
-    const validSchemas = schema.anyOf.filter(s => {
-        const errors = validateSchemaNode(value, s, path);
-        return errors.length === 0;
-    });
-    if (validSchemas.length === 0) {
-        return [
-            {
-                field: path,
-                message: "must match one of the allowed types",
-                value
-            }
-        ];
-    }
-    return [];
-}
-/**
- * Validates a record value.
- */
-function validateRecord(value, schema, path) {
-    const errors = [];
-    if (value === null || value === undefined) {
-        errors.push({
-            field: path,
-            message: "must be an object",
-            value
-        });
-        return errors;
-    }
-    if (typeof value !== "object") {
-        errors.push({
-            field: path,
-            message: "must be an object",
-            value
-        });
-        return errors;
-    }
-    // Validate each value in the record
-    for (const [key, recordValue] of Object.entries(value)) {
-        const recordPath = path ? `${path}.${key}` : key;
-        const recordErrors = validateSchemaNode(recordValue, schema.values, recordPath);
-        errors.push(...recordErrors);
-    }
-    return errors;
-}
-/**
- * Validates a null value.
- */
-function validateNull(value, schema, path) {
-    const errors = [];
-    if (value !== null) {
-        errors.push({
-            field: path,
-            message: "must be null",
-            value
-        });
-    }
-    return errors;
-}
-/**
- * Deep equality check for validation.
- */
-function isEqual(a, b) {
-    if (a === b)
-        return true;
-    if (typeof a !== typeof b)
-        return false;
-    if (typeof a === "object") {
-        if (a === null || b === null)
-            return false;
-        const aKeys = Object.keys(a);
-        const bKeys = Object.keys(b);
-        if (aKeys.length !== bKeys.length)
-            return false;
-        for (const key of aKeys) {
-            if (!isEqual(a[key], b[key]))
-                return false;
-        }
-        return true;
-    }
-    return false;
-}