@elsikora/nestjs-crud-automator/dist/cjs/class/metadata-storage.class.js

A library for automating the creation of CRUD operations in NestJS.

'use strict';

require('../constant/decorator/api/function.constant.js');
var propertyDescribe_constant = require('../constant/decorator/api/property-describe.constant.js');
var logger_utility = require('../utility/logger.utility.js');

const metadataStorageLogger = logger_utility.LoggerUtility.getLogger("MetadataStorage");
class EntityMetadataWrapper {
    entityName;
    PROPERTIES;
    constructor(entityName) {
        this.entityName = entityName;
        this.PROPERTIES = new Map();
    }
    asRecord() {
        return Object.fromEntries(this.PROPERTIES);
    }
    getName() {
        return this.entityName;
    }
    getProperty(propertyName) {
        return this.PROPERTIES.get(propertyName);
    }
    getPropertyCount() {
        return this.PROPERTIES.size;
    }
    setProperty(propertyName, key, value) {
        if (!this.PROPERTIES.has(propertyName)) {
            this.PROPERTIES.set(propertyName, { [propertyDescribe_constant.PROPERTY_DESCRIBE_DECORATOR_API_CONSTANT.METADATA_KEY]: {} });
        }
        // eslint-disable-next-line @elsikora/typescript/no-non-null-assertion
        const entry = this.PROPERTIES.get(propertyName);
        entry[key] = value;
    }
}
/**
 * Singleton class for storing and retrieving entity property metadata.
 * @see {@link https://elsikora.com/docs/nestjs-crud-automator/api-reference/classes#metadatastorage | API Reference - MetadataStorage}
 * @see {@link https://elsikora.com/docs/nestjs-crud-automator/core-concepts/metadata-storage | Core Concepts - Metadata Storage}
 */
class MetadataStorage {
    static instance;
    REGISTRY;
    constructor() {
        this.REGISTRY = new Map();
    }
    static getInstance() {
        if (!MetadataStorage.instance) {
            MetadataStorage.instance = new MetadataStorage();
        }
        return MetadataStorage.instance;
    }
    getAllEntitiesMetadata() {
        const result = {};
        for (const wrapper of this.REGISTRY.values()) {
            result[wrapper.getName()] = wrapper.asRecord();
        }
        return result;
    }
    getMetadata(entityName, propertyName, key) {
        const wrapper = this.REGISTRY.get(entityName);
        if (!wrapper)
            return undefined;
        if (!propertyName)
            return wrapper.asRecord();
        const propertyMetadata = wrapper.getProperty(propertyName);
        if (!propertyMetadata)
            return undefined;
        if (!key)
            return propertyMetadata;
        return propertyMetadata[key];
    }
    setMetadata(entityName, propertyName, key, value) {
        let wrapper = this.REGISTRY.get(entityName);
        if (!wrapper) {
            wrapper = new EntityMetadataWrapper(entityName);
            this.REGISTRY.set(entityName, wrapper);
            metadataStorageLogger.debug(`Registered new entity metadata wrapper for "${entityName}"`);
        }
        wrapper.setProperty(propertyName, key, value);
        metadataStorageLogger.debug(`Total properties for entity "${entityName}": ${wrapper.getPropertyCount()}`);
        metadataStorageLogger.debug(`All registered entities: [${[...this.REGISTRY.values()].map((w) => w.getName()).join(", ")}]`);
    }
}

exports.MetadataStorage = MetadataStorage;
//# sourceMappingURL=metadata-storage.class.js.map