@odata2ts/odata2ts/lib/data-model/validation/NameClashValidator.js

Flexible generator to produce various TypeScript artefacts (from simple model interfaces to complete odata clients) from OData metadata files

import { TypeModel } from "../../TypeModel.js";
export class NameClashValidator {
    constructor(options = {}) {
        this.options = options;
        this.entityContainer = new Map();
        this.store = new Map();
        this.errors = new Map();
    }
    addToError(name, hit, validationObject) {
        var _a;
        const existingErrors = this.errors.get(name);
        if (existingErrors) {
            if (!this.options.disableAutomaticNameClashResolution) {
                validationObject.renamedTo = `${name}${existingErrors.length + 1}`;
            }
            existingErrors.push(validationObject);
        }
        else {
            if (!this.options.disableAutomaticNameClashResolution) {
                validationObject.renamedTo = `${name}2`;
            }
            this.errors.set(name, [hit, validationObject]);
        }
        return (_a = validationObject.renamedTo) !== null && _a !== void 0 ? _a : name;
    }
    addToTypes(fqName, name, type) {
        const validationObject = { type, fqName };
        const hit = this.store.get(name);
        if (hit) {
            return this.addToError(name, hit, validationObject);
        }
        else {
            this.store.set(name, validationObject);
            return name;
        }
    }
    addToEntityContainer(fqName, name, type) {
        const validationObject = { type, fqName };
        const hit = this.entityContainer.get(name);
        if (hit) {
            return this.addToError(name, hit, validationObject);
        }
        else {
            this.entityContainer.set(name, validationObject);
            return name;
        }
    }
    addEntityType(fqName, name) {
        return this.addToTypes(fqName, name, TypeModel.EntityType);
    }
    addComplexType(fqName, name) {
        return this.addToTypes(fqName, name, TypeModel.ComplexType);
    }
    addEnumType(fqName, name) {
        return this.addToTypes(fqName, name, TypeModel.EnumType);
    }
    addUnboundOperationType(fqName, name, operationType) {
        const validationObject = { type: TypeModel.OperationType, fqName };
        const isAction = operationType === "Action" /* OperationTypes.Action */;
        const hit = this.store.get(name);
        // to support function overloads: allow multiple operation definitions with same fully qualified name
        if (hit && (isAction || hit.fqName !== fqName)) {
            return this.addToError(name, hit, validationObject);
        }
        else {
            this.store.set(name, validationObject);
            return name;
        }
    }
    addBoundOperationType(bindingName, fqName, name, operationType) {
        const nameWithBinding = `${bindingName}_${name}`;
        const validationObject = { type: TypeModel.OperationType, fqName };
        const isAction = operationType === "Action" /* OperationTypes.Action */;
        const hit = this.store.get(nameWithBinding);
        // to support function overloads: allow multiple operation definitions with same fully qualified name
        if (hit && (isAction || hit.fqName !== fqName)) {
            return this.addToError(name, hit, validationObject);
        }
        else {
            this.store.set(nameWithBinding, validationObject);
            return name;
        }
    }
    addOperationImportType(fqName, name) {
        return this.addToEntityContainer(fqName, name, TypeModel.OperationImportType);
    }
    addEntitySet(fqName, name) {
        return this.addToEntityContainer(fqName, name, TypeModel.EntitySet);
    }
    addSingleton(fqName, name) {
        return this.addToEntityContainer(fqName, name, TypeModel.Singleton);
    }
    validate() {
        return this.errors;
    }
}
//# sourceMappingURL=NameClashValidator.js.map