@sap/odata-v4/lib/edm/EdmEntityContainer.js

OData V4.0 server library

'use strict';

const EdmAnnotation = require('./EdmAnnotation');
const EdmEntitySet = require('./EdmEntitySet');
const EdmSingleton = require('./EdmSingleton');
const EdmActionImport = require('./EdmActionImport');
const EdmFunctionImport = require('./EdmFunctionImport');
const validateThat = require('../validator/ParameterValidator').validateThat;

/**
 * <a href="./../ODataSpecification/odata-v4.0-errata03-os/complete/part3-csdl/odata-v4.0-errata03-os-part3-csdl-complete.html#_Toc453752597">
 *     OData CSDL # 13.1 Element edm:EntityContainer
 * </a>
 * @hideconstructor
 */
class EdmEntityContainer {

    /**
     * Constructor
     * Use factory method EdmEntityContainer.createWithFQN or
     * EdmEntityContainer.createWithContainerInfo to create an entity container
     *
     * @param {Edm} edm The edm itself
     * @param {CsdlProvider} provider Provider for the Csdl artifacts
     * @param {CsdlEntityContainerInfo} [entityContainerInfo] Entity container info
     * @param {FullQualifiedName} [fqn] Full qualified name
     * @param {CsdlEntityContainer} [entityContainer]  Entity container
     * @param {Object} [configuration]  Edm configuration object
     */
    constructor(edm, provider, entityContainerInfo, fqn, entityContainer, configuration = {}) {
        validateThat('edm', edm).truthy();
        validateThat('provider', provider).truthy();
        if (!entityContainerInfo) {
            validateThat('fqn', fqn).truthy();
            validateThat('entityContainer', entityContainer).truthy();
        }

        /**
         * @type {Edm}
         * @private
         */
        this._edm = edm;

        /**
         * @type {string}
         * @private
         */
        this._name = null;

        /**
         * @type {FullQualifiedName}
         * @private
         */
        this._entityContainerName = null;

        /**
         * @type {FullQualifiedName}
         * @private
         */
        this._parentContainerName = null;

        /**
         * @type {CsdlEntityContainer}
         * @private
         */
        this.container = null;

        /**
         * @type {CsdlProvider}
         * @private
         */
        this._provider = provider;

        if (entityContainerInfo) {
            this._name = entityContainerInfo.name.name;
            this._entityContainerName = entityContainerInfo.name;
            this._parentContainerName = entityContainerInfo.extends;
        } else {
            this._name = fqn.name;
            this.container = entityContainer;
            this._entityContainerName = fqn;
            this._parentContainerName = entityContainer.extends;
        }

        /**
         * @type {EdmSingleton[]}
         * @private
         */
        this.singletons = null;

        /**
         * @type {Map.<string, EdmSingleton>}
         * @private
         */
        this.singletonCache = new Map();

        /**
         * @type {EdmEntitySet[]}
         * @private
         */
        this.entitySets = null;

        /**
         * @type {Map.<string, EdmEntitySet>}
         * @private
         */
        this.entitySetCache = new Map();

        /**
         * @type {EdmActionImport[]}
         * @private
         */
        this.actionImports = null;

        /**
         * @type {Map.<string, EdmActionImport>}
         * @private
         */
        this.actionImportCache = new Map();


        /**
         * @type {EdmFunctionImport[]}
         * @private
         */
        this.functionImports = null;

        /**
         * @type {Map.<string, EdmFunctionImport>}
         * @private
         */
        this.functionImportCache = new Map();

        /**
         * @type {EdmAnnotation[]}
         * @private
         */
        this.annotations = null;

        this._configuration = configuration;
    }

    /**
     * Return Namespace
     *
     * @returns {string}
     */
    getNamespace() {
        return this._entityContainerName.namespace;
    }

    /**
     * Return name
     *
     * @returns {string}
     */
    getName() {
        return this._entityContainerName.name;
    }

    /**
     * Return full qualified name
     *
     * @returns {FullQualifiedName}
     */
    getFullQualifiedName() {
        return this._entityContainerName;
    }

    /**
     * Get contained singleton by name.
     *
     * @param {string} singletonName Name of singleton, or null if not found
     * @returns {?EdmSingleton}
     */
    getSingleton(singletonName) {
        let singleton = this.singletonCache.get(singletonName); // EdmSingleton
        if (singleton) {
            return singleton;
        }

        singleton = this.createSingleton(singletonName);
        if (singleton) {
            this.singletonCache.set(singletonName, singleton);
        }
        return singleton;
    }

    /**
     * Get contained entity set by name.
     *
     * @param {string} entitySetName Name of entity set, or null if not found
     * @returns {?EdmEntitySet}
     */
    getEntitySet(entitySetName) {
        let entitySet = this.entitySetCache.get(entitySetName);
        if (entitySet) {
            return entitySet;
        }

        entitySet = this.createEntitySet(entitySetName);
        if (entitySet) {
            this.entitySetCache.set(entitySetName, entitySet);
        }

        return entitySet;
    }

    /**
     * Get contained action import by name, or null if not found
     *
     * @param {string} actionImportName Name of action import
     * @returns {?EdmActionImport}
     */
    getActionImport(actionImportName) {
        let actionImport = this.actionImportCache.get(actionImportName);
        if (actionImport) {
            return actionImport;
        }

        actionImport = this.createActionImport(actionImportName);
        if (actionImport) {
            this.actionImportCache.set(actionImportName, actionImport);
        }

        return actionImport;
    }

    /**
     * Get contained function import by name.
     *
     * @param {string} functionImportName Name of function import
     * @returns {?EdmFunctionImport}
     */
    getFunctionImport(functionImportName) {
        let functionImport = this.functionImportCache.get(functionImportName);
        if (functionImport) {
            return functionImport;
        }

        functionImport = this.createFunctionImport(functionImportName);
        if (functionImport != null) {
            this.functionImportCache.set(functionImportName, functionImport);
        }

        return functionImport;
    }

    /**
     * Returns all singletons
     *
     * @returns {EdmSingleton[]}
     */
    getSingletons() {
        if (!this.singletons) {
            this._loadAllSingletons();
        }
        return this.singletons;
    }

    /**
     * Returns all entity sets
     *
     * @returns {EdmEntitySet[]}
     */
    getEntitySets() {
        if (!this.entitySets) {
            this._loadAllEntitySets();
        }

        return this.entitySets;
    }

    /**
     * Loads and returns all action imports
     *
     * @returns {EdmActionImport[]}
     */
    getActionImports() {
        if (!this.actionImports) {
            this._loadAllActionImports();
        }
        return this.actionImports;
    }


    /**
     * Loads and returns all function imports
     *
     * @returns {EdmFunctionImport[]}
     */
    getFunctionImports() {
        if (!this.functionImports) {
            this._loadAllFunctionImports();
        }
        return this.functionImports;
    }


    /**
     * Returns the {@link FullQualifiedName} of the parent container or null
     * if no parent is specified
     *
     * @returns {FullQualifiedName}
     */
    getParentContainerName() {
        return this._parentContainerName;
    }

    /**
     * Creates a EdmSingleton instance using the Csdl provider
     * @param {string} singletonName Name of the singleton
     * @returns {EdmSingleton}
     * @private
     */
    createSingleton(singletonName) {
        const providerSingleton = this._provider.getSingleton(this._entityContainerName, singletonName);

        let config = this._getArtifactConfiguration(this.getNamespace(), singletonName);

        let singleton = null;
        if (providerSingleton) {
            singleton = new EdmSingleton(this._edm, this, providerSingleton, config);
        }

        return singleton;
    }

    /**
     * Creates a EdmEntitySet instance using the Csdl provider
     *
     * @param {string} entitySetName Name of the entity set
     * @returns {EdmEntitySet}
     * @private
     */
    createEntitySet(entitySetName) {
        const providerEntitySet = this._provider.getEntitySet(this._entityContainerName, entitySetName);

        let config = this._getArtifactConfiguration(this.getNamespace(), entitySetName);

        let entitySet = null;
        if (providerEntitySet) {
            entitySet = new EdmEntitySet(this._edm, this, providerEntitySet, config);
        }
        return entitySet;
    }


    /**
     * Creates a EdmActionImport instance using the Csdl provider
     *
     * @param {string} actionImportName Name of the action import
     * @returns {EdmActionImport}
     * @private
     */
    createActionImport(actionImportName) {
        let actionImport = null;

        let providerImport = this._provider.getActionImport(this._entityContainerName, actionImportName);
        if (providerImport) {
            actionImport = new EdmActionImport(this._edm, this, providerImport);
        }

        return actionImport;
    }

    /**
     * Creates a EdmFunctionImport instance using the Csdl provider
     *
     * @param {string} functionImportName Name of the function import
     * @returns {EdmFunctionImport}
     * @private
     */
    createFunctionImport(functionImportName) {
        let functionImport = null;

        let providerImport = this._provider.getFunctionImport(this._entityContainerName, functionImportName);
        if (providerImport) {
            functionImport = new EdmFunctionImport(this._edm, this, providerImport);
        }

        return functionImport;
    }


    /**
     * Load all singletons from the Csdl provider into the caches.
     * @private
     */
    _loadAllSingletons() {
        this._loadContainer();
        let providerSingletons = this.container.singletons;

        this.singletons = [];

        if (providerSingletons) {
            for (let csdlSingleton of providerSingletons) { // CsdlSingleton
                let config = this._getArtifactConfiguration(this.getNamespace(), csdlSingleton.name);
                let singleton = new EdmSingleton(this._edm, this, csdlSingleton, config); // EdmSingletonImpl
                this.singletonCache.set(csdlSingleton.name, singleton);
                this.singletons.push(singleton);
            }
        }
    }


    /**
     * Load all entity sets from the Csdl provider into the caches.
     * @private
     */
    _loadAllEntitySets() {
        this._loadContainer();
        let providerEntitySets = this.container.entitySets; // CsdlEntitySet

        this.entitySets = [];

        if (providerEntitySets) {
            for (let csdlEntitySet of providerEntitySets) {
                let config = this._getArtifactConfiguration(this.getNamespace(), csdlEntitySet.name);
                let entitySet = new EdmEntitySet(this._edm, this, csdlEntitySet, config);
                this.entitySetCache[entitySet.getName()] = entitySet;
                this.entitySets.push(entitySet);
            }
        }
    }


    /**
     * Load all action imports from the Csdl provider into the caches.
     * @private
     */
    _loadAllActionImports() {
        this._loadContainer();
        let providerActionImports = this.container.actionImports;

        this.actionImports = [];

        if (providerActionImports) {
            for (let csdlActionImport of providerActionImports) {
                let actionImport = new EdmActionImport(this._edm, this, csdlActionImport);
                this.actionImportCache.set(actionImport.name, actionImport);
                this.actionImports.push(actionImport);
            }
        }
    }

    /**
     * Load all function imports from the Csdl provider into the caches.
     * @private
     */
    _loadAllFunctionImports() {
        this._loadContainer();
        let providerFunctionImports = this.container.functionImports;

        this.functionImports = [];

        if (providerFunctionImports) {
            for (let csdlFunctionImport of providerFunctionImports) {
                let functionImport = new EdmFunctionImport(this._edm, this, csdlFunctionImport);
                this.functionImportCache.set(functionImport.name, functionImport);
                this.functionImports.push(functionImport);
            }
        }
    }


    /**
     * Load CsdlEntityContainer object from the Csdl provider if the EdmEntityContainer
     * was created with an CsdlContainerInfo object.
     * @private
     */
    _loadContainer() {
        if (this.container) {
            return;
        }

        /**
         * @type {CsdlEntityContainer}
         * @private
         */
        this.container = this._provider.getEntityContainer(this._entityContainerName);
    }

    /**
     * Returns the annotations for this object
     *
     * @returns {EdmAnnotation[]}
     */
    getAnnotations() {
        this._loadContainer();

        if (this.annotations) {
            return this.annotations;
        }

        this.annotations = [];
        for (let item of this.container.annotations) {
            this.annotations.push(new EdmAnnotation(this._edm, item));
        }

        return this.annotations;
    }

    /**
     * Creates a EdmEntityContainer instance from an ContainerInfo instance
     *
     * @param {Edm} edm The edm itself
     * @param {CsdlProvider} provider Provider for the Csdl artifacts
     * @param {CsdlEntityContainerInfo} entityContainerInfo Entity container info
     * @param {Object} configuration a configuration object
     * @returns {EdmEntityContainer}
     * @package
     */
    static createWithContainerInfo(edm, provider, entityContainerInfo, configuration) {
        return new EdmEntityContainer(edm, provider, entityContainerInfo, null, null, configuration);
    }

    /**
     * Creates a EdmEntityContainer instance from full qualified name and the CsdlEntityContainer
     *
     * @param {Edm} edm The edm itself
     * @param {CsdlProvider} provider Provider for the Csdl artifacts
     * @param {FullQualifiedName} fqn Full qualified name of container
     * @param {CsdlEntityContainer} entityContainer Entity container
     * @param {Object} configuration a configuration object
     * @returns {EdmEntityContainer}
     * @package
     */
    static createWithFQN(edm, provider, fqn, entityContainer, configuration) {
        return new EdmEntityContainer(edm, provider, null, fqn, entityContainer, configuration);
    }

    /**
     * @param {string} namespace
     * @param {string} name
     * @returns {?Object} configuration
     */
    _getArtifactConfiguration(namespace, name) {
        const nsConfig = this._configuration[namespace];
        return nsConfig ? nsConfig[name] : undefined;
    }
}

module.exports = EdmEntityContainer;