cxtms 1.9.13

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * TypeScript type definitions for CX Schema Validator
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/dist/utils/schemaLoader.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Schema loading and caching utilities
+ */
+import { SchemaEntry } from '../types';
+/**
+ * Recursively loads all JSON schema files from a directory
+ */
+export declare function loadSchemas(schemasDir: string): Map<string, SchemaEntry>;
+/**
+ * Resolves a relative reference to an absolute path
+ */
+export declare function resolveSchemaRef(ref: string, currentPath: string): string;
+/**
+ * Extracts examples from schema for error reporting
+ */
+export declare function extractExampleFromSchema(schema: any): any;
+//# sourceMappingURL=schemaLoader.d.ts.map

package/dist/utils/schemaLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaLoader.d.ts","sourceRoot":"","sources":["../../src/utils/schemaLoader.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC;;GAEG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAwBxE;AAiCD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAczE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAwBzD"}

package/dist/utils/schemaLoader.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Schema loading and caching utilities
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSchemas = loadSchemas;
+exports.resolveSchemaRef = resolveSchemaRef;
+exports.extractExampleFromSchema = extractExampleFromSchema;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Recursively loads all JSON schema files from a directory
+ */
+function loadSchemas(schemasDir) {
+    const schemas = new Map();
+    // Load main schemas.json
+    const mainSchemaPath = path.join(schemasDir, 'schemas.json');
+    if (fs.existsSync(mainSchemaPath)) {
+        const schema = JSON.parse(fs.readFileSync(mainSchemaPath, 'utf-8'));
+        schemas.set('schemas.json', {
+            schema,
+            uri: `file:///${mainSchemaPath.replace(/\\/g, '/')}`
+        });
+    }
+    // Load schemas from subdirectories
+    const subdirs = ['components', 'fields', 'actions'];
+    for (const subdir of subdirs) {
+        const subdirPath = path.join(schemasDir, subdir);
+        if (fs.existsSync(subdirPath)) {
+            loadSchemasFromDir(subdirPath, subdir, schemas);
+        }
+    }
+    return schemas;
+}
+/**
+ * Recursively loads schemas from a directory
+ */
+function loadSchemasFromDir(dir, relativePath, schemas) {
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            loadSchemasFromDir(filePath, `${relativePath}/${file}`, schemas);
+        }
+        else if (file.endsWith('.json')) {
+            try {
+                const schema = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                const key = `${relativePath}/${file}`;
+                schemas.set(key, {
+                    schema,
+                    uri: `file:///${filePath.replace(/\\/g, '/')}`
+                });
+            }
+            catch (error) {
+                console.error(`Error loading schema ${filePath}:`, error);
+            }
+        }
+    }
+}
+/**
+ * Resolves a relative reference to an absolute path
+ */
+function resolveSchemaRef(ref, currentPath) {
+    if (ref.startsWith('file://')) {
+        return ref;
+    }
+    // Handle relative paths
+    if (ref.startsWith('../') || ref.startsWith('./')) {
+        const currentDir = path.dirname(currentPath);
+        const resolved = path.normalize(path.join(currentDir, ref));
+        return resolved;
+    }
+    // Direct file reference
+    return ref;
+}
+/**
+ * Extracts examples from schema for error reporting
+ */
+function extractExampleFromSchema(schema) {
+    if (!schema)
+        return undefined;
+    // Check for x-example
+    if (schema['x-example'] !== undefined) {
+        return schema['x-example'];
+    }
+    // Check for x-examples
+    if (schema['x-examples'] !== undefined) {
+        return schema['x-examples'];
+    }
+    // Check for examples array
+    if (Array.isArray(schema.examples) && schema.examples.length > 0) {
+        return schema.examples[0];
+    }
+    // Check for enum values
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        return schema.enum;
+    }
+    return undefined;
+}
+//# sourceMappingURL=schemaLoader.js.map

package/dist/utils/schemaLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaLoader.js","sourceRoot":"","sources":["../../src/utils/schemaLoader.ts"],"names":[],"mappings":"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"}

package/dist/validator.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Main module validator
+ */
+import { ValidationResult, ValidatorOptions } from './types';
+export declare class ModuleValidator {
+    private ajv;
+    private schemas;
+    private schemasDir;
+    private options;
+    constructor(options?: ValidatorOptions);
+    /**
+     * Register all loaded schemas with Ajv
+     */
+    private registerSchemas;
+    /**
+     * Convert schema file path to schema ID for Ajv
+     */
+    private getSchemaId;
+    /**
+     * Validate a YAML module file
+     */
+    validateModule(filePath: string): Promise<ValidationResult>;
+    /**
+     * Normalize file path: forward slashes, strip leading ./
+     */
+    private normalizeFilePath;
+    /**
+     * Validate top-level module structure
+     */
+    private validateModuleStructure;
+    /**
+     * Validate components array
+     */
+    private validateComponents;
+    /**
+     * Validate a single component
+     */
+    private validateComponent;
+    /**
+     * Recursively validate nested components
+     */
+    private validateNestedComponent;
+    /**
+     * Validate component props that may contain nested components
+     */
+    private validateComponentProps;
+    /**
+     * Convert Ajv errors to our error format
+     */
+    private addAjvErrors;
+    /**
+     * Validate routes array
+     */
+    private validateRoutes;
+    /**
+     * Validate entities array
+     */
+    private validateEntities;
+    /**
+     * Validate configurations array
+     */
+    private validateConfigurations;
+    /**
+     * Check for deprecated properties
+     */
+    private checkDeprecatedProperties;
+    /**
+     * Create validation result
+     */
+    private createResult;
+}
+//# sourceMappingURL=validator.d.ts.map

package/dist/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../src/validator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,EACL,gBAAgB,EAGhB,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AAOjB,qBAAa,eAAe;IAC1B,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAA6B;gBAEhC,OAAO,GAAE,gBAAqB;IA2B1C;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;IACH,OAAO,CAAC,WAAW;IAOnB;;OAEG;IACG,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgEjE;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAyE/B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsCzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAwD/B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAuB9B;;OAEG;IACH,OAAO,CAAC,YAAY;IAkBpB;;OAEG;IACH,OAAO,CAAC,cAAc;IAwBtB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAiBxB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAwB9B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAqBjC;;OAEG;IACH,OAAO,CAAC,YAAY;CAwBrB"}

package/dist/validator.js

@@ -0,0 +1,432 @@
+"use strict";
+/**
+ * Main module validator
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleValidator = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const schemaLoader_1 = require("./utils/schemaLoader");
+class ModuleValidator {
+    constructor(options = {}) {
+        this.schemasDir = options.schemasPath || path.join(__dirname, '../schemas');
+        this.options = {
+            schemasPath: this.schemasDir,
+            strictMode: options.strictMode ?? true,
+            includeWarnings: options.includeWarnings ?? true
+        };
+        // Initialize Ajv with Draft 7 support
+        this.ajv = new ajv_1.default({
+            strict: false,
+            allErrors: true,
+            verbose: true,
+            validateFormats: true,
+            allowUnionTypes: true
+        });
+        // Add format validators
+        (0, ajv_formats_1.default)(this.ajv);
+        // Load all schemas
+        this.schemas = (0, schemaLoader_1.loadSchemas)(this.schemasDir);
+        // Register schemas with Ajv
+        this.registerSchemas();
+    }
+    /**
+     * Register all loaded schemas with Ajv
+     */
+    registerSchemas() {
+        // First, add all schemas to Ajv
+        for (const [key, entry] of this.schemas.entries()) {
+            try {
+                const schemaId = this.getSchemaId(key);
+                this.ajv.addSchema(entry.schema, schemaId);
+            }
+            catch (error) {
+                console.error(`Error adding schema ${key}:`, error);
+            }
+        }
+    }
+    /**
+     * Convert schema file path to schema ID for Ajv
+     */
+    getSchemaId(key) {
+        if (key === 'schemas.json') {
+            return 'schemas.json';
+        }
+        return key;
+    }
+    /**
+     * Validate a YAML module file
+     */
+    async validateModule(filePath) {
+        const errors = [];
+        const warnings = [];
+        try {
+            // Check if file exists
+            if (!fs.existsSync(filePath)) {
+                errors.push({
+                    type: 'file_not_found',
+                    path: filePath,
+                    message: `File not found: ${filePath}`
+                });
+                return this.createResult(filePath, errors, warnings);
+            }
+            // Read and parse YAML
+            const content = fs.readFileSync(filePath, 'utf-8');
+            let moduleData;
+            try {
+                moduleData = yaml_1.default.parse(content);
+            }
+            catch (yamlError) {
+                errors.push({
+                    type: 'yaml_syntax_error',
+                    path: filePath,
+                    message: `YAML syntax error: ${yamlError.message}`
+                });
+                return this.createResult(filePath, errors, warnings);
+            }
+            // Validate module structure
+            this.validateModuleStructure(moduleData, errors, warnings, filePath);
+            // Validate components
+            if (moduleData.components && Array.isArray(moduleData.components)) {
+                this.validateComponents(moduleData.components, errors, warnings);
+            }
+            // Validate routes
+            if (moduleData.routes && Array.isArray(moduleData.routes)) {
+                this.validateRoutes(moduleData.routes, errors, warnings);
+            }
+            // Validate entities
+            if (moduleData.entities && Array.isArray(moduleData.entities)) {
+                this.validateEntities(moduleData.entities, errors, warnings);
+            }
+            // Validate configurations
+            if (moduleData.configurations && Array.isArray(moduleData.configurations)) {
+                this.validateConfigurations(moduleData.configurations, errors, warnings);
+            }
+            return this.createResult(filePath, errors, warnings);
+        }
+        catch (error) {
+            errors.push({
+                type: 'unexpected_error',
+                path: filePath,
+                message: `Unexpected error: ${error.message}`
+            });
+            return this.createResult(filePath, errors, warnings);
+        }
+    }
+    /**
+     * Normalize file path: forward slashes, strip leading ./
+     */
+    normalizeFilePath(p) {
+        return p.replace(/\\/g, '/').replace(/^\.\//, '');
+    }
+    /**
+     * Validate top-level module structure
+     */
+    validateModuleStructure(moduleData, errors, warnings, filePath) {
+        // Check required top-level properties
+        if (!moduleData.module) {
+            errors.push({
+                type: 'missing_property',
+                path: 'module',
+                message: 'Missing required property: module'
+            });
+            return;
+        }
+        if (!moduleData.components) {
+            errors.push({
+                type: 'missing_property',
+                path: 'components',
+                message: 'Missing required property: components'
+            });
+        }
+        // Validate module metadata
+        const module = moduleData.module;
+        if (!module.name) {
+            errors.push({
+                type: 'missing_property',
+                path: 'module.name',
+                message: 'Missing required property: module.name'
+            });
+        }
+        if (!module.appModuleId) {
+            errors.push({
+                type: 'missing_property',
+                path: 'module.appModuleId',
+                message: 'Missing required property: module.appModuleId'
+            });
+        }
+        if (!module.displayName) {
+            errors.push({
+                type: 'missing_property',
+                path: 'module.displayName',
+                message: 'Missing required property: module.displayName'
+            });
+        }
+        // filePath / fileName deprecation and validation
+        if (module.fileName && !module.filePath) {
+            warnings.push({
+                type: 'deprecated_property',
+                path: 'module.fileName',
+                message: 'Use "filePath" instead of "fileName" in module section'
+            });
+        }
+        const declaredPath = module.filePath ?? module.fileName;
+        if (declaredPath && filePath) {
+            const normalizedActual = this.normalizeFilePath(filePath);
+            const normalizedDeclared = this.normalizeFilePath(declaredPath);
+            if (!normalizedActual.endsWith(normalizedDeclared)) {
+                warnings.push({
+                    type: 'file_path_mismatch',
+                    path: 'module.filePath',
+                    message: `Declared filePath "${normalizedDeclared}" does not match actual file path "${normalizedActual}"`
+                });
+            }
+        }
+    }
+    /**
+     * Validate components array
+     */
+    validateComponents(components, errors, warnings) {
+        components.forEach((component, index) => {
+            const componentPath = `components[${index}]`;
+            this.validateComponent(component, componentPath, errors, warnings);
+        });
+    }
+    /**
+     * Validate a single component
+     */
+    validateComponent(component, componentPath, errors, warnings) {
+        if (!component || typeof component !== 'object') {
+            errors.push({
+                type: 'invalid_component',
+                path: componentPath,
+                message: 'Component must be an object'
+            });
+            return;
+        }
+        // Check for required properties
+        if (!component.name) {
+            errors.push({
+                type: 'missing_property',
+                path: `${componentPath}.name`,
+                message: 'Component must have a name property'
+            });
+        }
+        // Validate layout if present
+        if (component.layout) {
+            this.validateNestedComponent(component.layout, `${componentPath}.layout`, errors, warnings);
+        }
+        // Check for deprecated properties
+        this.checkDeprecatedProperties(component, componentPath, warnings);
+    }
+    /**
+     * Recursively validate nested components
+     */
+    validateNestedComponent(component, componentPath, errors, warnings) {
+        if (!component || typeof component !== 'object') {
+            return;
+        }
+        const componentType = component.component;
+        if (!componentType) {
+            errors.push({
+                type: 'missing_property',
+                path: `${componentPath}.component`,
+                message: 'Component must have a component type'
+            });
+            return;
+        }
+        // Try to validate against specific component schema
+        const schemaKey = `components/${componentType}.json`;
+        if (this.schemas.has(schemaKey)) {
+            try {
+                const validate = this.ajv.getSchema(schemaKey);
+                if (validate && !validate(component)) {
+                    this.addAjvErrors(validate.errors, componentPath, errors);
+                }
+            }
+            catch (error) {
+                // Schema not found or validation error
+            }
+        }
+        // Recursively validate children
+        if (component.children && Array.isArray(component.children)) {
+            component.children.forEach((child, index) => {
+                this.validateNestedComponent(child, `${componentPath}.children[${index}]`, errors, warnings);
+            });
+        }
+        // Recursively validate props that may contain components
+        if (component.props) {
+            this.validateComponentProps(component.props, `${componentPath}.props`, errors, warnings);
+        }
+    }
+    /**
+     * Validate component props that may contain nested components
+     */
+    validateComponentProps(props, propsPath, errors, warnings) {
+        if (!props || typeof props !== 'object') {
+            return;
+        }
+        // Check for nested layouts or components in props
+        for (const [key, value] of Object.entries(props)) {
+            if (value && typeof value === 'object' && value.component) {
+                this.validateNestedComponent(value, `${propsPath}.${key}`, errors, warnings);
+            }
+        }
+    }
+    /**
+     * Convert Ajv errors to our error format
+     */
+    addAjvErrors(ajvErrors, basePath, errors) {
+        if (!ajvErrors)
+            return;
+        for (const error of ajvErrors) {
+            const errorPath = `${basePath}${error.instancePath}`;
+            errors.push({
+                type: 'schema_violation',
+                path: errorPath,
+                message: error.message || 'Schema validation failed',
+                schemaPath: error.schemaPath
+            });
+        }
+    }
+    /**
+     * Validate routes array
+     */
+    validateRoutes(routes, errors, warnings) {
+        routes.forEach((route, index) => {
+            const routePath = `routes[${index}]`;
+            if (!route.path) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${routePath}.path`,
+                    message: 'Route must have a path property'
+                });
+            }
+            if (!route.component) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${routePath}.component`,
+                    message: 'Route must have a component property'
+                });
+            }
+        });
+    }
+    /**
+     * Validate entities array
+     */
+    validateEntities(entities, errors, warnings) {
+        entities.forEach((entity, index) => {
+            const entityPath = `entities[${index}]`;
+            if (!entity.name) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${entityPath}.name`,
+                    message: 'Entity must have a name property'
+                });
+            }
+        });
+    }
+    /**
+     * Validate configurations array
+     */
+    validateConfigurations(configurations, errors, warnings) {
+        configurations.forEach((config, index) => {
+            const configPath = `configurations[${index}]`;
+            if (!config.configName) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${configPath}.configName`,
+                    message: 'Configuration must have a configName property'
+                });
+            }
+            if (!config.component) {
+                errors.push({
+                    type: 'missing_property',
+                    path: `${configPath}.component`,
+                    message: 'Configuration must have a component property'
+                });
+            }
+        });
+    }
+    /**
+     * Check for deprecated properties
+     */
+    checkDeprecatedProperties(obj, path, warnings) {
+        const deprecations = {
+            key: 'Use "name" instead of "key"',
+            type: 'Use "fieldType" instead of "type" for fields'
+        };
+        for (const [oldProp, message] of Object.entries(deprecations)) {
+            if (oldProp in obj) {
+                warnings.push({
+                    type: 'deprecated_property',
+                    path: `${path}.${oldProp}`,
+                    message
+                });
+            }
+        }
+    }
+    /**
+     * Create validation result
+     */
+    createResult(filePath, errors, warnings) {
+        const errorsByType = {};
+        errors.forEach(error => {
+            errorsByType[error.type] = (errorsByType[error.type] || 0) + 1;
+        });
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings: this.options.includeWarnings ? warnings : [],
+            summary: {
+                file: filePath,
+                timestamp: new Date().toISOString(),
+                status: errors.length === 0 ? 'PASSED' : 'FAILED',
+                errorCount: errors.length,
+                warningCount: warnings.length,
+                errorsByType
+            }
+        };
+    }
+}
+exports.ModuleValidator = ModuleValidator;
+//# sourceMappingURL=validator.js.map