@object-ui/core 0.3.0

package/dist/validation/schema-validator.js

@@ -0,0 +1,280 @@
+/**
+ * @object-ui/core - Schema Validation
+ *
+ * Runtime validation utilities for Object UI schemas.
+ * These utilities help ensure schemas are valid before rendering.
+ *
+ * @module validation
+ * @packageDocumentation
+ */
+/**
+ * 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');
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@object-ui/core",
+  "version": "0.3.0",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "zod": "^3.22.4",
+    "@object-ui/types": "0.3.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}

package/src/builder/schema-builder.d.ts

@@ -0,0 +1,287 @@
+/**
+ * @object-ui/core - Schema Builder
+ *
+ * Fluent API for building schemas programmatically.
+ * Provides type-safe builder functions for common schema patterns.
+ *
+ * @module builder
+ * @packageDocumentation
+ */
+import type { BaseSchema, FormSchema, FormField, CRUDSchema, TableColumn, ActionSchema, ButtonSchema, InputSchema, CardSchema, GridSchema, FlexSchema } from '@object-ui/types';
+/**
+ * Base builder class
+ */
+declare class SchemaBuilder<T extends BaseSchema> {
+    protected schema: any;
+    constructor(type: string);
+    /**
+     * Set the ID
+     */
+    id(id: string): this;
+    /**
+     * Set the className
+     */
+    className(className: string): this;
+    /**
+     * Set visibility
+     */
+    visible(visible: boolean): this;
+    /**
+     * Set conditional visibility
+     */
+    visibleOn(expression: string): this;
+    /**
+     * Set disabled state
+     */
+    disabled(disabled: boolean): this;
+    /**
+     * Set test ID
+     */
+    testId(testId: string): this;
+    /**
+     * Build the final schema
+     */
+    build(): T;
+}
+/**
+ * Form builder
+ */
+export declare class FormBuilder extends SchemaBuilder<FormSchema> {
+    constructor();
+    /**
+     * Add a field to the form
+     */
+    field(field: FormField): this;
+    /**
+     * Add multiple fields
+     */
+    fields(fields: FormField[]): this;
+    /**
+     * Set default values
+     */
+    defaultValues(values: Record<string, any>): this;
+    /**
+     * Set submit label
+     */
+    submitLabel(label: string): this;
+    /**
+     * Set form layout
+     */
+    layout(layout: 'vertical' | 'horizontal'): this;
+    /**
+     * Set number of columns
+     */
+    columns(columns: number): this;
+    /**
+     * Set submit handler
+     */
+    onSubmit(handler: (data: Record<string, any>) => void | Promise<void>): this;
+}
+/**
+ * CRUD builder
+ */
+export declare class CRUDBuilder extends SchemaBuilder<CRUDSchema> {
+    constructor();
+    /**
+     * Set resource name
+     */
+    resource(resource: string): this;
+    /**
+     * Set API endpoint
+     */
+    api(api: string): this;
+    /**
+     * Set title
+     */
+    title(title: string): this;
+    /**
+     * Set description
+     */
+    description(description: string): this;
+    /**
+     * Add a column
+     */
+    column(column: TableColumn): this;
+    /**
+     * Set all columns
+     */
+    columns(columns: TableColumn[]): this;
+    /**
+     * Set form fields
+     */
+    fields(fields: FormField[]): this;
+    /**
+     * Enable create operation
+     */
+    enableCreate(label?: string): this;
+    /**
+     * Enable update operation
+     */
+    enableUpdate(label?: string): this;
+    /**
+     * Enable delete operation
+     */
+    enableDelete(label?: string, confirmText?: string): this;
+    /**
+     * Set pagination
+     */
+    pagination(pageSize?: number): this;
+    /**
+     * Enable row selection
+     */
+    selectable(mode?: 'single' | 'multiple'): this;
+    /**
+     * Add a batch action
+     */
+    batchAction(action: ActionSchema): this;
+    /**
+     * Add a row action
+     */
+    rowAction(action: ActionSchema): this;
+}
+/**
+ * Button builder
+ */
+export declare class ButtonBuilder extends SchemaBuilder<ButtonSchema> {
+    constructor();
+    /**
+     * Set button label
+     */
+    label(label: string): this;
+    /**
+     * Set button variant
+     */
+    variant(variant: 'default' | 'secondary' | 'destructive' | 'outline' | 'ghost' | 'link'): this;
+    /**
+     * Set button size
+     */
+    size(size: 'default' | 'sm' | 'lg' | 'icon'): this;
+    /**
+     * Set button icon
+     */
+    icon(icon: string): this;
+    /**
+     * Set click handler
+     */
+    onClick(handler: () => void | Promise<void>): this;
+    /**
+     * Set loading state
+     */
+    loading(loading: boolean): this;
+}
+/**
+ * Input builder
+ */
+export declare class InputBuilder extends SchemaBuilder<InputSchema> {
+    constructor();
+    /**
+     * Set field name
+     */
+    name(name: string): this;
+    /**
+     * Set label
+     */
+    label(label: string): this;
+    /**
+     * Set placeholder
+     */
+    placeholder(placeholder: string): this;
+    /**
+     * Set input type
+     */
+    inputType(type: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url'): this;
+    /**
+     * Mark as required
+     */
+    required(required?: boolean): this;
+    /**
+     * Set default value
+     */
+    defaultValue(value: string | number): this;
+}
+/**
+ * Card builder
+ */
+export declare class CardBuilder extends SchemaBuilder<CardSchema> {
+    constructor();
+    /**
+     * Set card title
+     */
+    title(title: string): this;
+    /**
+     * Set card description
+     */
+    description(description: string): this;
+    /**
+     * Set card content
+     */
+    content(content: BaseSchema | BaseSchema[]): this;
+    /**
+     * Set card variant
+     */
+    variant(variant: 'default' | 'outline' | 'ghost'): this;
+    /**
+     * Make card hoverable
+     */
+    hoverable(hoverable?: boolean): this;
+}
+/**
+ * Grid builder
+ */
+export declare class GridBuilder extends SchemaBuilder<GridSchema> {
+    constructor();
+    /**
+     * Set number of columns
+     */
+    columns(columns: number): this;
+    /**
+     * Set gap
+     */
+    gap(gap: number): this;
+    /**
+     * Add a child
+     */
+    child(child: BaseSchema): this;
+    /**
+     * Set all children
+     */
+    children(children: BaseSchema[]): this;
+}
+/**
+ * Flex builder
+ */
+export declare class FlexBuilder extends SchemaBuilder<FlexSchema> {
+    constructor();
+    /**
+     * Set flex direction
+     */
+    direction(direction: 'row' | 'col' | 'row-reverse' | 'col-reverse'): this;
+    /**
+     * Set justify content
+     */
+    justify(justify: 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly'): this;
+    /**
+     * Set align items
+     */
+    align(align: 'start' | 'end' | 'center' | 'baseline' | 'stretch'): this;
+    /**
+     * Set gap
+     */
+    gap(gap: number): this;
+    /**
+     * Add a child
+     */
+    child(child: BaseSchema): this;
+    /**
+     * Set all children
+     */
+    children(children: BaseSchema[]): this;
+}
+export declare const form: () => FormBuilder;
+export declare const crud: () => CRUDBuilder;
+export declare const button: () => ButtonBuilder;
+export declare const input: () => InputBuilder;
+export declare const card: () => CardBuilder;
+export declare const grid: () => GridBuilder;
+export declare const flex: () => FlexBuilder;
+export {};