@seedprotocol/sdk 0.4.7 → 0.4.9

package/dist/SchemaValidationService-CIXKzSpb.js

@@ -0,0 +1,654 @@
+import { Value } from '@sinclair/typebox/value';
+import 'reflect-metadata';
+import { a as ModelPropertyDataTypes, T as TPropertyDataType, c as TProperty } from './index-j8WN8W6V.js';
+import 'pluralize';
+import 'drizzle-orm';
+import { Type } from '@sinclair/typebox';
+import debug from 'debug';
+import 'xstate';
+import 'drizzle-orm/sqlite-core';
+import 'nanoid';
+import 'nanoid-dictionary';
+import 'ethers';
+import 'rxjs';
+import 'lodash-es';
+import 'drizzle-orm/casing';
+import 'eventemitter3';
+import 'arweave';
+
+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(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 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 {
+            const isValid = Value.Check(TProperty, property);
+            const errors = [];
+            if (!isValid) {
+                const typeBoxErrors = [...Value.Errors(TProperty, property)];
+                errors.push(...typeBoxErrors.map(err => {
+                    const fieldPath = err.path || 'unknown';
+                    const fieldSchema = this.getSchemaForField(TProperty, fieldPath);
+                    const enhancedMessage = this.enhanceErrorMessage(err, fieldSchema || 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 = [
+                ModelPropertyDataTypes.Text,
+                ModelPropertyDataTypes.Number,
+                ModelPropertyDataTypes.Boolean,
+                ModelPropertyDataTypes.Date,
+                ModelPropertyDataTypes.Json,
+                ModelPropertyDataTypes.Image,
+                ModelPropertyDataTypes.File,
+                ModelPropertyDataTypes.Html,
+                ModelPropertyDataTypes.Relation,
+            ];
+            if (nonListTypes.includes(property.dataType)) {
+                const hasRefValueType = property.refValueType != null && String(property.refValueType).trim() !== '';
+                if (hasRefValueType) {
+                    // Relation may keep refValueType only for Image (relation to Image entity)
+                    if (property.dataType === ModelPropertyDataTypes.Relation && property.refValueType === ModelPropertyDataTypes.Image) {
+                        // Allowed: Relation to Image
+                    }
+                    else {
+                        errors.push({
+                            field: 'refValueType',
+                            message: `refValueType is only valid for List properties. Use dataType 'List' with refValueType '${property.refValueType}' for lists of ${property.refValueType}.`,
+                            code: 'invalid_ref_value_type',
+                            severity: 'error',
+                        });
+                    }
+                }
+            }
+            // List: refValueType is required
+            if (property.dataType === ModelPropertyDataTypes.List) {
+                const hasRefValueType = property.refValueType != null && String(property.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 && property.refValueType === ModelPropertyDataTypes.Relation) {
+                    const hasRef = property.ref && property.ref.trim() !== '';
+                    const hasRefModelName = property.refModelName && property.refModelName.trim() !== '';
+                    const hasRefModelId = property.refModelId !== undefined && property.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 (property.dataType === ModelPropertyDataTypes.Relation) {
+                const hasRef = property.ref && property.ref.trim() !== '';
+                const hasRefModelName = property.refModelName && property.refModelName.trim() !== '';
+                const hasRefModelId = property.refModelId !== undefined && property.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 "${property.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
+     */
+    validatePropertyValue(value, dataType, validationRules) {
+        const errors = [];
+        const warnings = [];
+        try {
+            // Array values are only allowed for List properties
+            if (dataType !== ModelPropertyDataTypes.List && Array.isArray(value)) {
+                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',
+                });
+            }
+            // Build base TypeBox schema from dataType
+            let schema = this.getBaseSchemaForDataType(dataType);
+            // Apply validation rules
+            if (validationRules) {
+                schema = this.applyValidationRules(schema, dataType, validationRules);
+            }
+            // Validate using TypeBox
+            const isValid = Value.Check(schema, value);
+            if (!isValid) {
+                const typeBoxErrors = [...Value.Errors(schema, value)];
+                errors.push(...typeBoxErrors.map(err => {
+                    const fieldPath = err.path || 'value';
+                    const enhancedMessage = this.enhanceErrorMessage(err, schema, fieldPath);
+                    return {
+                        field: fieldPath,
+                        message: enhancedMessage,
+                        code: String(err.type || 'value_validation_error'),
+                        severity: 'error',
+                    };
+                }));
+            }
+            // Additional custom validations
+            if (validationRules) {
+                const customErrors = this.validateCustomRules(value, 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);
+        }
+        // Validate property definition structure
+        if (!propertyDefinition.type) {
+            errors.push({
+                field: 'property.type',
+                message: 'Property type is required',
+                code: 'missing_type',
+                severity: 'error',
+            });
+        }
+        // Validate Relation: requires model
+        if (propertyDefinition.type === 'Relation') {
+            if (!propertyDefinition.model || propertyDefinition.model.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[propertyDefinition.model]) {
+                errors.push({
+                    field: 'property.model',
+                    message: `Referenced model "${propertyDefinition.model}" not found in schema`,
+                    code: 'invalid_reference',
+                    severity: 'error',
+                });
+            }
+        }
+        // Validate List: requires items with type; model required only when items.type === 'Relation'
+        if (propertyDefinition.type === 'List') {
+            const items = propertyDefinition.items;
+            if (!items || !items.type) {
+                errors.push({
+                    field: 'property.items',
+                    message: 'List properties require "items" with "type" (e.g. items: { type: "Text" } or items: { type: "Relation", model: "Tag" })',
+                    code: 'missing_items',
+                    severity: 'error',
+                });
+            }
+            else if (items.type === 'Relation' || items.type === 'RelationProperty') {
+                const model = items.model || propertyDefinition.model;
+                if (!model || String(model).trim() === '') {
+                    errors.push({
+                        field: 'property.items.model',
+                        message: 'List of relations requires "items.model" to specify the related model',
+                        code: 'missing_ref',
+                        severity: 'error',
+                    });
+                }
+                else if (schema.models && !schema.models[model]) {
+                    errors.push({
+                        field: 'property.items.model',
+                        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 ModelPropertyDataTypes.Text:
+            case ModelPropertyDataTypes.Html:
+                return Type.String();
+            case ModelPropertyDataTypes.Number:
+                return Type.Number();
+            case ModelPropertyDataTypes.Boolean:
+                return Type.Boolean();
+            case ModelPropertyDataTypes.Date:
+                return Type.String({ format: 'date-time' });
+            case ModelPropertyDataTypes.Json:
+                return Type.Any();
+            case ModelPropertyDataTypes.List:
+                return Type.Array(Type.Any());
+            case ModelPropertyDataTypes.Relation:
+            case ModelPropertyDataTypes.Image:
+            case ModelPropertyDataTypes.File:
+                return Type.Union([Type.String(), Type.Null()]);
+            default:
+                return 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 === ModelPropertyDataTypes.Text || dataType === ModelPropertyDataTypes.Html)) {
+            try {
+                const regex = new RegExp(rules.pattern);
+                result = Type.RegExp(regex);
+            }
+            catch (error) {
+                logger('Invalid regex pattern:', rules.pattern, error);
+            }
+        }
+        // Apply minLength/maxLength for strings
+        if (dataType === ModelPropertyDataTypes.Text || dataType === ModelPropertyDataTypes.Html) {
+            Type.String();
+            if (rules.minLength !== undefined) {
+                result = Type.String({ minLength: rules.minLength });
+            }
+            if (rules.maxLength !== undefined) {
+                if (rules.minLength !== undefined) {
+                    result = Type.String({ minLength: rules.minLength, maxLength: rules.maxLength });
+                }
+                else {
+                    result = Type.String({ maxLength: rules.maxLength });
+                }
+            }
+        }
+        // Apply enum
+        if (rules.enum && Array.isArray(rules.enum) && rules.enum.length > 0) {
+            result = Type.Union(rules.enum.map(val => 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;
+    }
+}
+
+export { SchemaValidationService };
+//# sourceMappingURL=SchemaValidationService-CIXKzSpb.js.map