@patchworkdev/common/dist/codegen/validateSchema.js

Patchwork Development Kit

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSchema = validateSchema;
const _2019_1 = __importDefault(require("ajv/dist/2019"));
const fs_1 = __importDefault(require("fs"));
const jsonProjectConfigLoader_1 = require("../configgen/jsonProjectConfigLoader");
const contractSchema_1 = require("./contractSchema");
const contractSchemaJsonParser_1 = require("./contractSchemaJsonParser");
function isValidNameIdentifier(name) {
    return /^[^0-9].*$/.test(name);
}
function createErrorObject(keyword, message, params) {
    return {
        keyword,
        instancePath: "",
        schemaPath: `#/${keyword}`,
        params,
        message
    };
}
function validateContractConfig(jsonData) {
    try {
        if (typeof jsonData !== 'object' || jsonData === null) {
            throw new Error('Invalid contract config format');
        }
        const config = jsonData;
        if (!isValidNameIdentifier(config.name)) {
            throw new Error('Contract name must not start with a number');
        }
        const contractSchema = (0, contractSchemaJsonParser_1.parseJson)(jsonData);
        new contractSchema_1.ContractSchemaImpl(contractSchema).validate();
        return { isValid: true, errors: [] };
    }
    catch (error) {
        return {
            isValid: false,
            errors: [createErrorObject("contractSchema", error.message, {})]
        };
    }
}
function validateProjectConfig(jsonData) {
    try {
        if (typeof jsonData !== 'object' || jsonData === null) {
            throw new Error('Invalid project config format');
        }
        const config = jsonData;
        if (!isValidNameIdentifier(config.name)) {
            throw new Error('Project name must not start with a number');
        }
        // Also validate names of all contracts within the project config
        if (config.contracts) {
            for (const [contractName, contractConfig] of Object.entries(config.contracts)) {
                if (typeof contractConfig === 'object') {
                    if (!isValidNameIdentifier(contractConfig.name)) {
                        throw new Error(`Contract "${contractName}" name must not start with a number`);
                    }
                }
            }
        }
        const projectConfigLoader = new jsonProjectConfigLoader_1.JSONProjectConfigLoader();
        const projectConfig = projectConfigLoader.load(JSON.stringify(jsonData));
        return { isValid: true, errors: [] };
    }
    catch (error) {
        return {
            isValid: false,
            errors: [createErrorObject("projectConfig", error.message, {})]
        };
    }
}
function validateSchema(jsonData, schemaFile) {
    try {
        const schemaData = JSON.parse(fs_1.default.readFileSync(schemaFile, 'utf8'));
        const ajv = new _2019_1.default();
        const validate = ajv.compile(schemaData);
        if (typeof jsonData !== 'object' || jsonData === null) {
            return {
                isValid: false,
                errors: [createErrorObject("type", "must be object", { type: "object" })]
            };
        }
        const schema = jsonData.$schema;
        if (schema === undefined) {
            return {
                isValid: false,
                errors: [createErrorObject("required", "must have required property '$schema'", { missingProperty: '$schema' })]
            };
        }
        const allowedSchemas = [
            "https://patchwork.dev/schema/patchwork-contract-config.schema.json",
            "https://patchwork.dev/schema/patchwork-project-config.schema.json"
        ];
        if (!allowedSchemas.includes(schema)) {
            return {
                isValid: false,
                errors: [createErrorObject("const", "must be one of", { allowedValues: allowedSchemas })]
            };
        }
        const valid = validate(jsonData);
        if (!valid) {
            return {
                isValid: false,
                errors: validate.errors || []
            };
        }
        if (schema === "https://patchwork.dev/schema/patchwork-contract-config.schema.json") {
            return validateContractConfig(jsonData);
        }
        else if (schema === "https://patchwork.dev/schema/patchwork-project-config.schema.json") {
            return validateProjectConfig(jsonData);
        }
    }
    catch (error) {
        console.error("Error reading schema file:", error.message);
        return {
            isValid: false,
            errors: [createErrorObject("$schema", error.message, {})]
        };
    }
    return {
        isValid: true,
        errors: []
    };
}