@seedprotocol/sdk 0.7.3-next.613.g79a8dfd → 0.7.3

package/dist/cjs/SchemaValidationService-CKNW1bKg.js

@@ -1,778 +0,0 @@
-'use strict';
-
-var value = require('@sinclair/typebox/value');
-require('reflect-metadata');
-var main_cjs = require('./index-usKaANAq.js');
-require('pluralize');
-require('drizzle-orm');
-var typebox = require('@sinclair/typebox');
-var debug = require('debug');
-require('immer');
-require('xstate');
-require('drizzle-orm/sqlite-core');
-require('@seedprotocol/arweave');
-require('@seedprotocol/eas');
-require('drizzle-orm/casing');
-require('lodash-es');
-require('nanoid');
-require('nanoid-dictionary');
-require('@seedprotocol/query');
-require('rxjs');
-require('@noble/hashes/sha3');
-require('@noble/hashes/utils');
-require('fs/promises');
-require('fs');
-require('path');
-require('url');
-require('node:url');
-require('@libsql/client');
-require('drizzle-orm/libsql');
-require('drizzle-orm/libsql/migrator');
-require('js-yaml');
-require('child_process');
-require('@seedprotocol/arweave/node');
-require('@seedprotocol/eas/node');
-
-const logger = debug('seedSdk:schema:validation');
-/**
- * Service for validating schemas, models, and properties using TypeBox
- */
-class SchemaValidationService {
-    /**
-     * Enhance TypeBox error message with expected values for union/literal types
-     */
-    enhanceErrorMessage(error, schema, fieldPath) {
-        const originalMessage = error.message || 'Validation failed';
-        // Handle Union type errors (like TPropertyDataType)
-        if (error.type === 'Union' || originalMessage.includes('union')) {
-            const expectedValues = this.extractExpectedValues(schema, fieldPath);
-            if (expectedValues.length > 0) {
-                return `Expected one of: ${expectedValues.join(', ')}. Received: ${JSON.stringify(error.value)}`;
-            }
-        }
-        // Handle Literal type errors
-        if (error.type === 'Literal') {
-            const expectedValue = this.extractLiteralValue(schema, fieldPath);
-            if (expectedValue !== undefined) {
-                return `Expected: ${JSON.stringify(expectedValue)}. Received: ${JSON.stringify(error.value)}`;
-            }
-        }
-        // Return enhanced message with value info if available
-        if (error.value !== undefined) {
-            return `${originalMessage}. Received: ${JSON.stringify(error.value)}`;
-        }
-        return originalMessage;
-    }
-    /**
-     * Extract expected values from a schema for a given field path
-     */
-    extractExpectedValues(schema, fieldPath) {
-        try {
-            // Handle TProperty schema - check if this is the dataType field
-            if (fieldPath === '/dataType' || fieldPath.endsWith('/dataType')) {
-                // Return all ModelPropertyDataTypes enum values
-                return Object.values(main_cjs.ModelPropertyDataTypes);
-            }
-            // Handle TStorageType
-            if (fieldPath === '/storageType' || fieldPath.endsWith('/storageType')) {
-                return ['ItemStorage', 'PropertyStorage'];
-            }
-            // If we have a schema, try to extract from it
-            if (!schema) {
-                return [];
-            }
-            // Try to extract from TypeBox Union type using the schema directly
-            const schemaObj = schema;
-            const kind = schemaObj[Symbol.for('TypeBox.Kind')];
-            if (kind === 'Union') {
-                const union = schemaObj;
-                const anyOf = union.anyOf || [];
-                const values = [];
-                for (const item of anyOf) {
-                    const itemKind = item?.[Symbol.for('TypeBox.Kind')];
-                    if (itemKind === 'Literal') {
-                        const literal = item;
-                        if (literal.const !== undefined) {
-                            values.push(String(literal.const));
-                        }
-                    }
-                }
-                if (values.length > 0) {
-                    return values;
-                }
-            }
-            // Fallback: try to extract from JSON schema format
-            if (typeof schema === 'object' && 'anyOf' in schema) {
-                const union = schema;
-                if (Array.isArray(union.anyOf)) {
-                    return union.anyOf
-                        .map((item) => {
-                        if (item.const !== undefined)
-                            return String(item.const);
-                        if (item.enum && Array.isArray(item.enum))
-                            return item.enum.map(String);
-                        return null;
-                    })
-                        .filter((val) => val !== null)
-                        .flat()
-                        .map(String);
-                }
-            }
-        }
-        catch (error) {
-            logger('Error extracting expected values:', error);
-        }
-        return [];
-    }
-    /**
-     * Extract literal value from a schema
-     */
-    extractLiteralValue(schema, fieldPath) {
-        try {
-            if (schema && typeof schema === 'object') {
-                const schemaObj = schema;
-                if (schemaObj[Symbol.for('TypeBox.Kind')] === 'Literal') {
-                    return schemaObj.const;
-                }
-                if (schemaObj.const !== undefined) {
-                    return schemaObj.const;
-                }
-            }
-        }
-        catch (error) {
-            logger('Error extracting literal value:', error);
-        }
-        return undefined;
-    }
-    /**
-     * Get the schema for a specific field path
-     */
-    getSchemaForField(schema, fieldPath) {
-        try {
-            if (!schema || typeof schema !== 'object')
-                return null;
-            // Remove leading slash
-            const path = fieldPath.replace(/^\//, '');
-            if (!path)
-                return schema;
-            const schemaObj = schema;
-            const kind = schemaObj[Symbol.for('TypeBox.Kind')];
-            // For TProperty (Object type), check properties
-            if (kind === 'Object') {
-                const properties = schemaObj.properties;
-                if (properties && properties[path]) {
-                    return properties[path];
-                }
-            }
-            // Special handling for known fields - return the actual schema
-            if (path === 'dataType') {
-                return main_cjs.TPropertyDataType;
-            }
-            // Fallback: check if schema has the property
-            if (path in schemaObj) {
-                return schemaObj[path];
-            }
-        }
-        catch (error) {
-            logger('Error getting schema for field:', error);
-        }
-        return null;
-    }
-    /**
-     * Validate a property structure against TProperty schema
-     */
-    validatePropertyStructure(property) {
-        try {
-            // Normalize dataType and refValueType for case-insensitive schema support (e.g. "relation" -> "Relation")
-            const normalized = { ...property };
-            if (typeof normalized.dataType === 'string') {
-                normalized.dataType = main_cjs.normalizeDataType(normalized.dataType);
-            }
-            if (typeof normalized.refValueType === 'string') {
-                normalized.refValueType = main_cjs.normalizeDataType(normalized.refValueType);
-            }
-            const isValid = value.Value.Check(main_cjs.TProperty, normalized);
-            const errors = [];
-            if (!isValid) {
-                const typeBoxErrors = [...value.Value.Errors(main_cjs.TProperty, normalized)];
-                errors.push(...typeBoxErrors.map(err => {
-                    const fieldPath = err.path || 'unknown';
-                    const fieldSchema = this.getSchemaForField(main_cjs.TProperty, fieldPath);
-                    const enhancedMessage = this.enhanceErrorMessage(err, fieldSchema || main_cjs.TProperty, fieldPath);
-                    return {
-                        field: fieldPath,
-                        message: enhancedMessage,
-                        code: String(err.type || 'validation_error'),
-                        severity: 'error',
-                    };
-                }));
-            }
-            // Non-List types: refValueType is only valid for Relation+Image (related entity type). Reject otherwise.
-            const nonListTypes = [
-                main_cjs.ModelPropertyDataTypes.Text,
-                main_cjs.ModelPropertyDataTypes.Number,
-                main_cjs.ModelPropertyDataTypes.Boolean,
-                main_cjs.ModelPropertyDataTypes.Date,
-                main_cjs.ModelPropertyDataTypes.Json,
-                main_cjs.ModelPropertyDataTypes.Image,
-                main_cjs.ModelPropertyDataTypes.File,
-                main_cjs.ModelPropertyDataTypes.Html,
-                main_cjs.ModelPropertyDataTypes.Relation,
-            ];
-            if (nonListTypes.includes(normalized.dataType)) {
-                const hasRefValueType = normalized.refValueType != null && String(normalized.refValueType).trim() !== '';
-                if (hasRefValueType) {
-                    // Relation may keep refValueType only for Image (relation to Image entity)
-                    if (normalized.dataType === main_cjs.ModelPropertyDataTypes.Relation && normalized.refValueType === main_cjs.ModelPropertyDataTypes.Image) {
-                        // Allowed: Relation to Image
-                    }
-                    else {
-                        errors.push({
-                            field: 'refValueType',
-                            message: `refValueType is only valid for List properties. Use dataType 'List' with refValueType '${normalized.refValueType}' for lists of ${normalized.refValueType}.`,
-                            code: 'invalid_ref_value_type',
-                            severity: 'error',
-                        });
-                    }
-                }
-            }
-            // List: refValueType is required
-            if (normalized.dataType === main_cjs.ModelPropertyDataTypes.List) {
-                const hasRefValueType = normalized.refValueType != null && String(normalized.refValueType).trim() !== '';
-                if (!hasRefValueType) {
-                    errors.push({
-                        field: 'refValueType',
-                        message: `List properties require refValueType (e.g. 'Text', 'Number', 'Relation') to specify the element type.`,
-                        code: 'missing_ref_value_type',
-                        severity: 'error',
-                    });
-                }
-                // List of relations: ref is required
-                if (hasRefValueType && normalized.refValueType === main_cjs.ModelPropertyDataTypes.Relation) {
-                    const hasRef = normalized.ref && normalized.ref.trim() !== '';
-                    const hasRefModelName = normalized.refModelName && normalized.refModelName.trim() !== '';
-                    const hasRefModelId = normalized.refModelId !== undefined && normalized.refModelId !== null;
-                    if (!hasRef && !hasRefModelName && !hasRefModelId) {
-                        errors.push({
-                            field: 'ref',
-                            message: `List properties with refValueType 'Relation' require either a "ref", "refModelName", or "refModelId" field to be defined`,
-                            code: 'missing_ref',
-                            severity: 'error',
-                        });
-                    }
-                }
-            }
-            // Relation (single): ref is required
-            if (normalized.dataType === main_cjs.ModelPropertyDataTypes.Relation) {
-                const hasRef = normalized.ref && normalized.ref.trim() !== '';
-                const hasRefModelName = normalized.refModelName && normalized.refModelName.trim() !== '';
-                const hasRefModelId = normalized.refModelId !== undefined && normalized.refModelId !== null;
-                if (!hasRef && !hasRefModelName && !hasRefModelId) {
-                    errors.push({
-                        field: 'ref',
-                        message: `Property with dataType "Relation" requires either a "ref", "refModelName", or "refModelId" field to be defined`,
-                        code: 'missing_ref',
-                        severity: 'error',
-                    });
-                }
-                if ((hasRef || hasRefModelName) && !hasRefModelId) {
-                    logger(`Property "${normalized.name}" has ref/refModelName but no refModelId - will be resolved asynchronously`);
-                }
-            }
-            return {
-                isValid: errors.length === 0,
-                errors,
-            };
-        }
-        catch (error) {
-            logger('Error validating property structure:', error);
-            return {
-                isValid: false,
-                errors: [{
-                        field: 'property',
-                        message: error instanceof Error ? error.message : 'Unknown validation error',
-                        code: 'validation_exception',
-                        severity: 'error',
-                    }],
-            };
-        }
-    }
-    /**
-     * Validate a property value against its validation rules
-     * @param value - The value to validate
-     * @param dataType - The property's data type
-     * @param validationRules - Optional validation rules (enum, pattern, minLength, maxLength)
-     * @param refValueType - For List properties: the element type (Text, Number, etc.). When set, each array element is validated against this type + validationRules.
-     */
-    validatePropertyValue(value$1, dataType, validationRules, refValueType) {
-        dataType = main_cjs.normalizeDataType(dataType);
-        const errors = [];
-        const warnings = [];
-        try {
-            // Array values are only allowed for List properties
-            if (dataType !== main_cjs.ModelPropertyDataTypes.List && Array.isArray(value$1)) {
-                errors.push({
-                    field: 'value',
-                    message: 'Array values are only allowed for List properties. Use dataType "List" with refValueType to store multiple values.',
-                    code: 'array_not_allowed',
-                    severity: 'error',
-                });
-            }
-            // File/Image: accept File objects from OS picker, and Blobs for Image (saveImage persists both).
-            // The TypeBox schema only allows string|null.
-            const isFileObject = typeof File !== 'undefined' && value$1 instanceof File;
-            const isBlobObject = typeof Blob !== 'undefined' && value$1 instanceof Blob;
-            if ((dataType === main_cjs.ModelPropertyDataTypes.File && isFileObject) ||
-                (dataType === main_cjs.ModelPropertyDataTypes.Image && isBlobObject)) {
-                if (validationRules) {
-                    const customErrors = this.validateCustomRules(value$1, validationRules);
-                    errors.push(...customErrors);
-                }
-                return {
-                    isValid: errors.length === 0,
-                    errors,
-                    warnings: warnings.length > 0 ? warnings : undefined,
-                };
-            }
-            // List with refValueType: validate each element against element schema + validation rules
-            if (dataType === main_cjs.ModelPropertyDataTypes.List && refValueType && Array.isArray(value$1)) {
-                const elementDataType = main_cjs.normalizeDataType(String(refValueType));
-                // Apply default maxLength for Text elements in List. Html elements hold arbitrary-length content.
-                const elementEffectiveRules = validationRules ? { ...validationRules } : {};
-                if (elementDataType === main_cjs.ModelPropertyDataTypes.Text && elementEffectiveRules.maxLength === undefined) {
-                    elementEffectiveRules.maxLength = main_cjs.DEFAULT_TEXT_MAX_LENGTH;
-                }
-                for (let i = 0; i < value$1.length; i++) {
-                    const elementResult = this.validatePropertyValue(value$1[i], elementDataType, elementEffectiveRules);
-                    if (!elementResult.isValid && elementResult.errors.length > 0) {
-                        for (const err of elementResult.errors) {
-                            errors.push({
-                                field: `value[${i}]`,
-                                message: `Element at index ${i}: ${err.message}`,
-                                code: validationRules?.enum && Array.isArray(validationRules.enum) && validationRules.enum.length > 0 ? 'enum_violation' : err.code,
-                                severity: err.severity,
-                            });
-                        }
-                    }
-                }
-                if (validationRules) {
-                    const customErrors = this.validateCustomRules(value$1, validationRules);
-                    errors.push(...customErrors);
-                }
-                return {
-                    isValid: errors.length === 0,
-                    errors,
-                    warnings: warnings.length > 0 ? warnings : undefined,
-                };
-            }
-            // List without refValueType or non-array: validate as scalar/array
-            if (dataType === main_cjs.ModelPropertyDataTypes.List && !Array.isArray(value$1) && value$1 != null) {
-                errors.push({
-                    field: 'value',
-                    message: 'List properties require an array value.',
-                    code: 'array_required',
-                    severity: 'error',
-                });
-                return { isValid: false, errors };
-            }
-            // Build base TypeBox schema from dataType
-            let schema = this.getBaseSchemaForDataType(dataType);
-            // Apply default maxLength for Text when not explicitly set. Html holds arbitrary-length content (e.g. article body) and must not default to 255.
-            const effectiveRules = validationRules ? { ...validationRules } : {};
-            if (dataType === main_cjs.ModelPropertyDataTypes.Text && effectiveRules.maxLength === undefined) {
-                effectiveRules.maxLength = main_cjs.DEFAULT_TEXT_MAX_LENGTH;
-            }
-            // Apply validation rules
-            const hasEnumRules = !!(validationRules?.enum && Array.isArray(validationRules.enum) && validationRules.enum.length > 0);
-            if (Object.keys(effectiveRules).length > 0) {
-                schema = this.applyValidationRules(schema, dataType, effectiveRules);
-            }
-            // Validate using TypeBox
-            const isValid = value.Value.Check(schema, value$1);
-            if (!isValid) {
-                const typeBoxErrors = [...value.Value.Errors(schema, value$1)];
-                const effectiveMaxLength = effectiveRules.maxLength;
-                const isDefaultTextLimit = dataType === main_cjs.ModelPropertyDataTypes.Text &&
-                    effectiveMaxLength === main_cjs.DEFAULT_TEXT_MAX_LENGTH &&
-                    validationRules?.maxLength === undefined;
-                errors.push(...typeBoxErrors.map(err => {
-                    const fieldPath = err.path || 'value';
-                    const originalMessage = (err.message || '').toLowerCase();
-                    // TypeBox maxLength errors have message like "Expected string length less or equal to X"
-                    const isMaxLengthError = originalMessage.includes('length') && (originalMessage.includes('less') || originalMessage.includes('equal') || originalMessage.includes('max'));
-                    let enhancedMessage;
-                    if (isMaxLengthError && effectiveMaxLength !== undefined) {
-                        const typeLabel = dataType === main_cjs.ModelPropertyDataTypes.Html ? 'Html' : 'Text';
-                        if (isDefaultTextLimit) {
-                            enhancedMessage = `Text properties have a default limit of 255 characters. For longer content, use a File property instead, which can hold arbitrary amounts of text or data.`;
-                        }
-                        else {
-                            enhancedMessage = `${typeLabel} must be ${effectiveMaxLength} characters or less. For longer content, use a File property instead, which can hold arbitrary amounts of text or data.`;
-                        }
-                    }
-                    else {
-                        enhancedMessage = this.enhanceErrorMessage(err, schema, fieldPath);
-                    }
-                    // Use max_length_exceeded when failure is due to maxLength; enum_violation when enum rules; else generic
-                    const code = isMaxLengthError
-                        ? 'max_length_exceeded'
-                        : hasEnumRules
-                            ? 'enum_violation'
-                            : String(err.type || 'value_validation_error');
-                    return {
-                        field: fieldPath,
-                        message: enhancedMessage,
-                        code,
-                        severity: 'error',
-                    };
-                }));
-            }
-            // Additional custom validations
-            if (validationRules) {
-                const customErrors = this.validateCustomRules(value$1, validationRules);
-                errors.push(...customErrors);
-            }
-            return {
-                isValid: errors.length === 0,
-                errors,
-                warnings: warnings.length > 0 ? warnings : undefined,
-            };
-        }
-        catch (error) {
-            logger('Error validating property value:', error);
-            return {
-                isValid: false,
-                errors: [{
-                        field: 'value',
-                        message: error instanceof Error ? error.message : 'Unknown validation error',
-                        code: 'validation_exception',
-                        severity: 'error',
-                    }],
-            };
-        }
-    }
-    /**
-     * Validate a specific property within a schema
-     */
-    validateProperty(schema, modelName, propertyName, propertyData) {
-        const errors = [];
-        // Check if model exists
-        if (!schema.models || !schema.models[modelName]) {
-            errors.push({
-                field: 'model',
-                message: `Model "${modelName}" not found in schema`,
-                code: 'model_not_found',
-                severity: 'error',
-            });
-            return { isValid: false, errors };
-        }
-        const model = schema.models[modelName];
-        // Check if property exists in model
-        // If the property name has changed (renamed), check if the original name exists
-        let propertyDefinition = model.properties?.[propertyName];
-        if (!propertyDefinition && propertyData?._originalValues?.name) {
-            const originalName = propertyData._originalValues.name;
-            // If the current name differs from the original, check if original exists
-            if (originalName !== propertyName && model.properties?.[originalName]) {
-                propertyDefinition = model.properties[originalName];
-                // Property is being renamed, which is allowed - continue validation
-            }
-        }
-        if (!propertyDefinition) {
-            errors.push({
-                field: 'property',
-                message: `Property "${propertyName}" not found in model "${modelName}"`,
-                code: 'property_not_found',
-                severity: 'error',
-            });
-            return { isValid: false, errors };
-        }
-        // If propertyData is provided, validate its structure
-        if (propertyData) {
-            const structureResult = this.validatePropertyStructure(propertyData);
-            errors.push(...structureResult.errors);
-        }
-        // Schema context definitions come in two shapes: schema-file ({ type, model }) and runtime
-        // ({ dataType, ref/refModelName }, e.g. models added from Model instances). Accept both, as the
-        // List check below already does; requiring `type` rejected every edit to a runtime-shaped property.
-        const definitionType = propertyDefinition.type ?? propertyDefinition.dataType;
-        const definitionRefModel = propertyDefinition.model ?? propertyDefinition.ref ?? propertyDefinition.refModelName;
-        // Validate property definition structure
-        if (!definitionType) {
-            errors.push({
-                field: 'property.type',
-                message: 'Property type is required',
-                code: 'missing_type',
-                severity: 'error',
-            });
-        }
-        // Validate Relation: requires model
-        if (main_cjs.isDataType(definitionType, main_cjs.ModelPropertyDataTypes.Relation)) {
-            if (!definitionRefModel || definitionRefModel.trim() === '') {
-                errors.push({
-                    field: 'property.model',
-                    message: `Property with type "Relation" requires a "model" field to be defined`,
-                    code: 'missing_ref',
-                    severity: 'error',
-                });
-            }
-            else if (!schema.models[definitionRefModel]) {
-                errors.push({
-                    field: 'property.model',
-                    message: `Referenced model "${definitionRefModel}" not found in schema`,
-                    code: 'invalid_reference',
-                    severity: 'error',
-                });
-            }
-        }
-        // Validate List: requires refValueType; ref (model) required only when refValueType === 'Relation' (case-insensitive)
-        if (main_cjs.isDataType(propertyDefinition.type, main_cjs.ModelPropertyDataTypes.List) || main_cjs.isDataType(propertyDefinition.dataType, main_cjs.ModelPropertyDataTypes.List)) {
-            const rawRefValueType = propertyDefinition.refValueType ?? propertyDefinition.items?.type ?? propertyDefinition.refvaluetype;
-            const refValueType = rawRefValueType ? main_cjs.normalizeDataType(String(rawRefValueType)) : undefined;
-            if (!refValueType || String(refValueType).trim() === '') {
-                errors.push({
-                    field: 'property.refValueType',
-                    message: 'List properties require "refValueType" (e.g. refValueType: "Text" or refValueType: "Relation" with ref: "Tag")',
-                    code: 'missing_ref_value_type',
-                    severity: 'error',
-                });
-            }
-            else if (refValueType === 'Relation' || refValueType === 'RelationProperty') {
-                const model = propertyDefinition.ref ?? propertyDefinition.model ?? propertyDefinition.items?.model;
-                if (!model || String(model).trim() === '') {
-                    errors.push({
-                        field: 'property.ref',
-                        message: 'List of relations requires "ref" to specify the related model',
-                        code: 'missing_ref',
-                        severity: 'error',
-                    });
-                }
-                else if (schema.models && !schema.models[model]) {
-                    errors.push({
-                        field: 'property.ref',
-                        message: `Referenced model "${model}" not found in schema`,
-                        code: 'invalid_reference',
-                        severity: 'error',
-                    });
-                }
-            }
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-        };
-    }
-    /**
-     * Validate model structure (basic structure checks)
-     */
-    validateModelStructure(model) {
-        const errors = [];
-        // Validate model name
-        if (!model.modelName || model.modelName.trim() === '') {
-            errors.push({
-                field: 'modelName',
-                message: 'Model name is required',
-                code: 'missing_model_name',
-                severity: 'error',
-            });
-        }
-        // Validate schema name
-        if (!model.schemaName || model.schemaName.trim() === '') {
-            errors.push({
-                field: 'schemaName',
-                message: 'Schema name is required',
-                code: 'missing_schema_name',
-                severity: 'error',
-            });
-        }
-        // Validate properties is an object
-        if (model.properties && typeof model.properties !== 'object') {
-            errors.push({
-                field: 'properties',
-                message: 'Properties must be an object',
-                code: 'invalid_properties',
-                severity: 'error',
-            });
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-        };
-    }
-    /**
-     * Validate a model against a schema WITHOUT requiring it to be in the schema's context
-     * This allows validation before registration, preventing update loops
-     */
-    validateModelAgainstSchema(schema, modelName, modelData) {
-        // Create a temporary schema context that includes this model for validation purposes
-        // This allows validateProperty to work without actually adding the model to the real schema
-        const tempSchemaContext = {
-            ...schema,
-            models: {
-                ...schema.models,
-                [modelName]: {
-                    properties: modelData.properties || {},
-                },
-            },
-        };
-        // Use validateModel which now works because the model is in the temp context
-        return this.validateModel(tempSchemaContext, modelName, modelData);
-    }
-    /**
-     * Validate a model within a schema (requires model to already be in schema context)
-     */
-    validateModel(schema, modelName, modelData) {
-        const errors = [];
-        if (!schema.models || !schema.models[modelName]) {
-            errors.push({
-                field: 'model',
-                message: `Model "${modelName}" not found in schema`,
-                code: 'model_not_found',
-                severity: 'error',
-            });
-            return { isValid: false, errors };
-        }
-        const model = schema.models[modelName];
-        // Validate all properties in the model
-        if (model.properties) {
-            for (const [propertyName, propertyDef] of Object.entries(model.properties)) {
-                const propertyResult = this.validateProperty(schema, modelName, propertyName);
-                if (!propertyResult.isValid) {
-                    errors.push(...propertyResult.errors.map(err => ({
-                        ...err,
-                        field: `${modelName}.${propertyName}.${err.field}`,
-                    })));
-                }
-            }
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-        };
-    }
-    /**
-     * Validate entire schema
-     */
-    validateSchema(schema) {
-        const errors = [];
-        // Validate schema name
-        if (!schema.schemaName || schema.schemaName.trim() === '') {
-            errors.push({
-                field: 'schemaName',
-                message: 'Schema name is required',
-                code: 'missing_schema_name',
-                severity: 'error',
-            });
-        }
-        // Validate metadata
-        if (!schema.metadata) {
-            errors.push({
-                field: 'metadata',
-                message: 'Schema metadata is required',
-                code: 'missing_metadata',
-                severity: 'error',
-            });
-        }
-        else {
-            if (!schema.metadata.name || schema.metadata.name.trim() === '') {
-                errors.push({
-                    field: 'metadata.name',
-                    message: 'Schema metadata name is required',
-                    code: 'missing_metadata_name',
-                    severity: 'error',
-                });
-            }
-        }
-        // Validate models if they exist
-        if (schema.models && Object.keys(schema.models).length > 0) {
-            // Validate each model
-            for (const modelName of Object.keys(schema.models)) {
-                const modelResult = this.validateModel(schema, modelName);
-                if (!modelResult.isValid) {
-                    errors.push(...modelResult.errors);
-                }
-            }
-        }
-        return {
-            isValid: errors.length === 0,
-            errors,
-        };
-    }
-    /**
-     * Get base TypeBox schema for a data type
-     */
-    getBaseSchemaForDataType(dataType) {
-        switch (dataType) {
-            case main_cjs.ModelPropertyDataTypes.Text:
-            case main_cjs.ModelPropertyDataTypes.Html:
-                return typebox.Type.String();
-            case main_cjs.ModelPropertyDataTypes.Number:
-                return typebox.Type.Number();
-            case main_cjs.ModelPropertyDataTypes.Boolean:
-                return typebox.Type.Boolean();
-            case main_cjs.ModelPropertyDataTypes.Date:
-                return typebox.Type.String({ format: 'date-time' });
-            case main_cjs.ModelPropertyDataTypes.Json:
-                return typebox.Type.Any();
-            case main_cjs.ModelPropertyDataTypes.List:
-                return typebox.Type.Array(typebox.Type.Any());
-            case main_cjs.ModelPropertyDataTypes.Relation:
-            case main_cjs.ModelPropertyDataTypes.Image:
-            case main_cjs.ModelPropertyDataTypes.File:
-                return typebox.Type.Union([typebox.Type.String(), typebox.Type.Null()]);
-            default:
-                return typebox.Type.Any();
-        }
-    }
-    /**
-     * Apply validation rules to a TypeBox schema
-     */
-    applyValidationRules(schema, dataType, rules) {
-        let result = schema;
-        // Apply pattern (regex) for strings
-        if (rules.pattern && (dataType === main_cjs.ModelPropertyDataTypes.Text || dataType === main_cjs.ModelPropertyDataTypes.Html)) {
-            try {
-                const regex = new RegExp(rules.pattern);
-                result = typebox.Type.RegExp(regex);
-            }
-            catch (error) {
-                logger('Invalid regex pattern:', rules.pattern, error);
-            }
-        }
-        // Apply minLength/maxLength for strings
-        if (dataType === main_cjs.ModelPropertyDataTypes.Text || dataType === main_cjs.ModelPropertyDataTypes.Html) {
-            typebox.Type.String();
-            if (rules.minLength !== undefined) {
-                result = typebox.Type.String({ minLength: rules.minLength });
-            }
-            if (rules.maxLength !== undefined) {
-                if (rules.minLength !== undefined) {
-                    result = typebox.Type.String({ minLength: rules.minLength, maxLength: rules.maxLength });
-                }
-                else {
-                    result = typebox.Type.String({ maxLength: rules.maxLength });
-                }
-            }
-        }
-        // Apply enum
-        if (rules.enum && Array.isArray(rules.enum) && rules.enum.length > 0) {
-            result = typebox.Type.Union(rules.enum.map(val => typebox.Type.Literal(val)));
-        }
-        return result;
-    }
-    /**
-     * Validate custom validation rules
-     */
-    validateCustomRules(value, rules) {
-        const errors = [];
-        // Custom validator reference (would need to be implemented based on your needs)
-        if (rules.custom) {
-            // TODO: Implement custom validator lookup and execution
-            logger('Custom validator not yet implemented:', rules.custom);
-        }
-        return errors;
-    }
-}
-
-exports.SchemaValidationService = SchemaValidationService;
-//# sourceMappingURL=SchemaValidationService-CKNW1bKg.js.map