@eventcatalog/linter/dist/validators/schema-validator.js

A linter for EventCatalog to validate frontmatter and resource references

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAllSchemas = exports.validateSchema = void 0;
const zod_1 = require("zod");
const schemas_1 = require("../schemas");
const validateSchema = (parsedFile) => {
    const { file, frontmatter } = parsedFile;
    const schema = schemas_1.schemas[file.resourceType];
    const errors = [];
    try {
        schema.parse(frontmatter);
    }
    catch (error) {
        if (error instanceof zod_1.z.ZodError) {
            for (const issue of error.issues) {
                const field = issue.path.join('.');
                let message = issue.message;
                if (issue.code === 'invalid_type') {
                    message = `Expected ${issue.expected}, but received ${issue.received}`;
                }
                let rule = 'schema/required-fields';
                if (issue.code === 'invalid_type') {
                    rule = 'schema/valid-type';
                }
                else if (issue.code === 'invalid_string' && issue.validation === 'email') {
                    rule = 'schema/valid-email';
                }
                else if (field && field.includes('version')) {
                    rule = 'schema/valid-semver';
                }
                errors.push({
                    type: 'schema',
                    resource: `${file.resourceType}/${file.resourceId}`,
                    field: field || undefined,
                    message: field ? `${field}: ${message}` : message,
                    file: file.relativePath,
                    rule,
                });
            }
        }
        else {
            errors.push({
                type: 'schema',
                resource: `${file.resourceType}/${file.resourceId}`,
                message: error instanceof Error ? error.message : String(error),
                file: file.relativePath,
                rule: 'schema/validation-error',
            });
        }
    }
    return errors;
};
exports.validateSchema = validateSchema;
const validateAllSchemas = (parsedFiles) => {
    const errors = [];
    for (const parsedFile of parsedFiles) {
        errors.push(...(0, exports.validateSchema)(parsedFile));
    }
    return errors;
};
exports.validateAllSchemas = validateAllSchemas;
//# sourceMappingURL=schema-validator.js.map