@object-ui/core 0.3.1 → 0.5.0

package/src/utils/filter-converter.js

@@ -1,100 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * Map MongoDB-like operators to ObjectStack filter operators.
- *
- * @param operator - MongoDB-style operator (e.g., '$gte', '$in')
- * @returns ObjectStack operator or null if not recognized
- */
-export function convertOperatorToAST(operator) {
-    const operatorMap = {
-        '$eq': '=',
-        '$ne': '!=',
-        '$gt': '>',
-        '$gte': '>=',
-        '$lt': '<',
-        '$lte': '<=',
-        '$in': 'in',
-        '$nin': 'notin',
-        '$notin': 'notin',
-        '$contains': 'contains',
-        '$startswith': 'startswith',
-        '$between': 'between',
-    };
-    return operatorMap[operator] || null;
-}
-/**
- * Convert object-based filters to ObjectStack FilterNode AST format.
- * Converts MongoDB-like operators to ObjectStack filter expressions.
- *
- * @param filter - Object-based filter with optional operators
- * @returns FilterNode AST array
- *
- * @example
- * // Simple filter - converted to AST
- * convertFiltersToAST({ status: 'active' })
- * // => ['status', '=', 'active']
- *
- * @example
- * // Complex filter with operators
- * convertFiltersToAST({ age: { $gte: 18 } })
- * // => ['age', '>=', 18]
- *
- * @example
- * // Multiple conditions
- * convertFiltersToAST({ age: { $gte: 18, $lte: 65 }, status: 'active' })
- * // => ['and', ['age', '>=', 18], ['age', '<=', 65], ['status', '=', 'active']]
- *
- * @throws {Error} If an unknown operator is encountered
- */
-export function convertFiltersToAST(filter) {
-    const conditions = [];
-    for (const [field, value] of Object.entries(filter)) {
-        if (value === null || value === undefined)
-            continue;
-        // Check if value is a complex operator object
-        if (typeof value === 'object' && !Array.isArray(value)) {
-            // Handle operator-based filters
-            for (const [operator, operatorValue] of Object.entries(value)) {
-                // Special handling for $regex - warn users about limited support
-                if (operator === '$regex') {
-                    console.warn(`[ObjectUI] Warning: $regex operator is not fully supported. ` +
-                        `Converting to 'contains' which only supports substring matching, not regex patterns. ` +
-                        `Field: '${field}', Value: ${JSON.stringify(operatorValue)}. ` +
-                        `Consider using $contains or $startswith instead.`);
-                    conditions.push([field, 'contains', operatorValue]);
-                    continue;
-                }
-                const astOperator = convertOperatorToAST(operator);
-                if (astOperator) {
-                    conditions.push([field, astOperator, operatorValue]);
-                }
-                else {
-                    // Unknown operator - throw error to avoid silent failure
-                    throw new Error(`[ObjectUI] Unknown filter operator '${operator}' for field '${field}'. ` +
-                        `Supported operators: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $contains, $startswith, $between. ` +
-                        `If you need exact object matching, use the value directly without an operator.`);
-                }
-            }
-        }
-        else {
-            // Simple equality filter
-            conditions.push([field, '=', value]);
-        }
-    }
-    // If no conditions, return original filter
-    if (conditions.length === 0) {
-        return filter;
-    }
-    // If only one condition, return it directly
-    if (conditions.length === 1) {
-        return conditions[0];
-    }
-    // Multiple conditions: combine with 'and'
-    return ['and', ...conditions];
-}

package/src/validation/schema-validator.d.ts

@@ -1,94 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * @object-ui/core - Schema Validation
- *
- * Runtime validation utilities for Object UI schemas.
- * These utilities help ensure schemas are valid before rendering.
- *
- * @module validation
- * @packageDocumentation
- */
-import type { BaseSchema } from '@object-ui/types';
-/**
- * Validation error details
- */
-export interface ValidationError {
-    path: string;
-    message: string;
-    type: 'error' | 'warning';
-    code?: string;
-}
-/**
- * Validation result
- */
-export interface ValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-    warnings: ValidationError[];
-}
-/**
- * Validate a complete schema
- *
- * @param schema - The schema to validate
- * @param options - Validation options
- * @returns Validation result with errors and warnings
- *
- * @example
- * ```typescript
- * const result = validateSchema({
- *   type: 'form',
- *   fields: [
- *     { name: 'email', type: 'input' }
- *   ]
- * });
- *
- * if (!result.valid) {
- *   console.error('Validation errors:', result.errors);
- * }
- * ```
- */
-export declare function validateSchema(schema: any, path?: string): ValidationResult;
-/**
- * Assert that a schema is valid, throwing an error if not
- *
- * @param schema - The schema to validate
- * @throws Error if schema is invalid
- *
- * @example
- * ```typescript
- * try {
- *   assertValidSchema(schema);
- *   // Schema is valid, continue rendering
- * } catch (error) {
- *   console.error('Invalid schema:', error.message);
- * }
- * ```
- */
-export declare function assertValidSchema(schema: any): asserts schema is BaseSchema;
-/**
- * Check if a value is a valid schema
- *
- * @param value - The value to check
- * @returns True if the value is a valid schema
- *
- * @example
- * ```typescript
- * if (isValidSchema(data)) {
- *   renderSchema(data);
- * }
- * ```
- */
-export declare function isValidSchema(value: any): value is BaseSchema;
-/**
- * Get a human-readable error summary
- *
- * @param result - The validation result
- * @returns Formatted error summary
- */
-export declare function formatValidationErrors(result: ValidationResult): string;

package/src/validation/schema-validator.js

@@ -1,278 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * Validation rules for base schema
- */
-const BASE_SCHEMA_RULES = {
-    type: {
-        required: true,
-        validate: (value) => typeof value === 'string' && value.length > 0,
-        message: 'type must be a non-empty string'
-    },
-    id: {
-        required: false,
-        validate: (value) => typeof value === 'string',
-        message: 'id must be a string'
-    },
-    className: {
-        required: false,
-        validate: (value) => typeof value === 'string',
-        message: 'className must be a string'
-    },
-    visible: {
-        required: false,
-        validate: (value) => typeof value === 'boolean',
-        message: 'visible must be a boolean'
-    },
-    disabled: {
-        required: false,
-        validate: (value) => typeof value === 'boolean',
-        message: 'disabled must be a boolean'
-    }
-};
-/**
- * Validate a schema against base rules
- */
-function validateBaseSchema(schema, path = 'schema') {
-    const errors = [];
-    if (!schema || typeof schema !== 'object') {
-        errors.push({
-            path,
-            message: 'Schema must be an object',
-            type: 'error',
-            code: 'INVALID_SCHEMA'
-        });
-        return errors;
-    }
-    // Validate required and optional properties
-    Object.entries(BASE_SCHEMA_RULES).forEach(([key, rule]) => {
-        const value = schema[key];
-        if (rule.required && value === undefined) {
-            errors.push({
-                path: `${path}.${key}`,
-                message: `${key} is required`,
-                type: 'error',
-                code: 'MISSING_REQUIRED'
-            });
-        }
-        if (value !== undefined && !rule.validate(value)) {
-            errors.push({
-                path: `${path}.${key}`,
-                message: rule.message,
-                type: 'error',
-                code: 'INVALID_TYPE'
-            });
-        }
-    });
-    return errors;
-}
-/**
- * Validate CRUD schema specific properties
- */
-function validateCRUDSchema(schema, path = 'schema') {
-    const errors = [];
-    if (schema.type === 'crud') {
-        // Check required properties for CRUD
-        if (!schema.columns || !Array.isArray(schema.columns)) {
-            errors.push({
-                path: `${path}.columns`,
-                message: 'CRUD schema requires columns array',
-                type: 'error',
-                code: 'MISSING_COLUMNS'
-            });
-        }
-        if (!schema.api && !schema.dataSource) {
-            errors.push({
-                path: `${path}.api`,
-                message: 'CRUD schema requires api or dataSource',
-                type: 'warning',
-                code: 'MISSING_DATA_SOURCE'
-            });
-        }
-        // Validate columns
-        if (schema.columns && Array.isArray(schema.columns)) {
-            schema.columns.forEach((column, index) => {
-                if (!column.name) {
-                    errors.push({
-                        path: `${path}.columns[${index}]`,
-                        message: 'Column requires name property',
-                        type: 'error',
-                        code: 'MISSING_COLUMN_NAME'
-                    });
-                }
-            });
-        }
-        // Validate fields if present
-        if (schema.fields && Array.isArray(schema.fields)) {
-            schema.fields.forEach((field, index) => {
-                if (!field.name) {
-                    errors.push({
-                        path: `${path}.fields[${index}]`,
-                        message: 'Field requires name property',
-                        type: 'error',
-                        code: 'MISSING_FIELD_NAME'
-                    });
-                }
-            });
-        }
-    }
-    return errors;
-}
-/**
- * Validate form schema specific properties
- */
-function validateFormSchema(schema, path = 'schema') {
-    const errors = [];
-    if (schema.type === 'form') {
-        if (schema.fields && Array.isArray(schema.fields)) {
-            schema.fields.forEach((field, index) => {
-                if (!field.name) {
-                    errors.push({
-                        path: `${path}.fields[${index}]`,
-                        message: 'Form field requires name property',
-                        type: 'error',
-                        code: 'MISSING_FIELD_NAME'
-                    });
-                }
-                // Check for duplicate field names
-                const duplicates = schema.fields.filter((f) => f.name === field.name);
-                if (duplicates.length > 1) {
-                    errors.push({
-                        path: `${path}.fields[${index}]`,
-                        message: `Duplicate field name: ${field.name}`,
-                        type: 'warning',
-                        code: 'DUPLICATE_FIELD_NAME'
-                    });
-                }
-            });
-        }
-    }
-    return errors;
-}
-/**
- * Validate child schemas recursively
- */
-function validateChildren(schema, path = 'schema') {
-    const errors = [];
-    const children = schema.children || schema.body;
-    if (children) {
-        if (Array.isArray(children)) {
-            children.forEach((child, index) => {
-                if (typeof child === 'object' && child !== null) {
-                    const childResult = validateSchema(child, `${path}.children[${index}]`);
-                    errors.push(...childResult.errors, ...childResult.warnings);
-                }
-            });
-        }
-        else if (typeof children === 'object' && children !== null) {
-            const childResult = validateSchema(children, `${path}.children`);
-            errors.push(...childResult.errors, ...childResult.warnings);
-        }
-    }
-    return errors;
-}
-/**
- * Validate a complete schema
- *
- * @param schema - The schema to validate
- * @param options - Validation options
- * @returns Validation result with errors and warnings
- *
- * @example
- * ```typescript
- * const result = validateSchema({
- *   type: 'form',
- *   fields: [
- *     { name: 'email', type: 'input' }
- *   ]
- * });
- *
- * if (!result.valid) {
- *   console.error('Validation errors:', result.errors);
- * }
- * ```
- */
-export function validateSchema(schema, path = 'schema') {
-    const allErrors = [];
-    // Validate base schema
-    allErrors.push(...validateBaseSchema(schema, path));
-    // Validate type-specific schemas
-    allErrors.push(...validateCRUDSchema(schema, path));
-    allErrors.push(...validateFormSchema(schema, path));
-    // Validate children recursively
-    allErrors.push(...validateChildren(schema, path));
-    const errors = allErrors.filter(e => e.type === 'error');
-    const warnings = allErrors.filter(e => e.type === 'warning');
-    return {
-        valid: errors.length === 0,
-        errors,
-        warnings
-    };
-}
-/**
- * Assert that a schema is valid, throwing an error if not
- *
- * @param schema - The schema to validate
- * @throws Error if schema is invalid
- *
- * @example
- * ```typescript
- * try {
- *   assertValidSchema(schema);
- *   // Schema is valid, continue rendering
- * } catch (error) {
- *   console.error('Invalid schema:', error.message);
- * }
- * ```
- */
-export function assertValidSchema(schema) {
-    const result = validateSchema(schema);
-    if (!result.valid) {
-        const errorMessages = result.errors.map(e => `${e.path}: ${e.message}`).join('\n');
-        throw new Error(`Schema validation failed:\n${errorMessages}`);
-    }
-}
-/**
- * Check if a value is a valid schema
- *
- * @param value - The value to check
- * @returns True if the value is a valid schema
- *
- * @example
- * ```typescript
- * if (isValidSchema(data)) {
- *   renderSchema(data);
- * }
- * ```
- */
-export function isValidSchema(value) {
-    const result = validateSchema(value);
-    return result.valid;
-}
-/**
- * Get a human-readable error summary
- *
- * @param result - The validation result
- * @returns Formatted error summary
- */
-export function formatValidationErrors(result) {
-    const parts = [];
-    if (result.errors.length > 0) {
-        parts.push('Errors:');
-        result.errors.forEach(error => {
-            parts.push(`  - ${error.path}: ${error.message}`);
-        });
-    }
-    if (result.warnings.length > 0) {
-        parts.push('Warnings:');
-        result.warnings.forEach(warning => {
-            parts.push(`  - ${warning.path}: ${warning.message}`);
-        });
-    }
-    return parts.join('\n');
-}