express-cargo/dist/cjs/metadata.js

express middleware for class-based request parsing

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: Object.getOwnPropertyDescriptor(all, name).get
    });
}
_export(exports, {
    get CargoClassMetadata () {
        return CargoClassMetadata;
    },
    get CargoFieldMetadata () {
        return CargoFieldMetadata;
    }
});
require("reflect-metadata");
function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
class CargoClassMetadata {
    getMetadataKey(propertyKey) {
        return `cargo:${String(propertyKey)}`;
    }
    getFieldKey() {
        return `cargo:fields`;
    }
    getRequestFieldKey() {
        return 'cargo:requestFields';
    }
    getVirtualFieldKey() {
        return 'cargo:virtualFields';
    }
    getCacheKey(metadataKey) {
        return `__cache__${metadataKey}`;
    }
    markBindingCargoCalled() {
        this.metadataFinalized = true;
    }
    getFieldMetadata(propertyKey) {
        const metadataKey = this.getMetadataKey(propertyKey);
        return Reflect.getMetadata(metadataKey, this.target) || new CargoFieldMetadata(this.target, propertyKey);
    }
    setFieldMetadata(propertyKey, meta) {
        const metaKey = this.getMetadataKey(propertyKey);
        Reflect.defineMetadata(metaKey, meta, this.target);
    }
    getFieldListByKey(metadataKey) {
        if (this.metadataFinalized) {
            const cached = Reflect.getMetadata(this.getCacheKey(metadataKey), this.target);
            if (cached) return cached;
        }
        const fields = new Set();
        let current = this.target;
        while(current && current !== Object.prototype){
            const currentFields = Reflect.getMetadata(metadataKey, current) || [];
            currentFields.forEach((f)=>fields.add(f));
            current = Object.getPrototypeOf(current);
        }
        const fieldList = Array.from(fields);
        // flag가 true일 때만 캐싱
        if (this.metadataFinalized) {
            Reflect.defineMetadata(this.getCacheKey(metadataKey), fieldList, this.target);
        }
        return fieldList;
    }
    setFieldListByKey(metadataKey, propertyKey) {
        const existing = this.getFieldListByKey(metadataKey);
        if (!existing.includes(propertyKey)) {
            Reflect.defineMetadata(metadataKey, [
                ...existing,
                propertyKey
            ], this.target);
            if (this.metadataFinalized) {
                Reflect.deleteMetadata(this.getCacheKey(metadataKey), this.target);
            }
        }
    }
    getFieldList() {
        return this.getFieldListByKey(this.getFieldKey());
    }
    setFieldList(propertyKey) {
        this.setFieldListByKey(this.getFieldKey(), propertyKey);
    }
    getRequestFieldList() {
        return this.getFieldListByKey(this.getRequestFieldKey());
    }
    setRequestFieldList(propertyKey) {
        this.setFieldListByKey(this.getRequestFieldKey(), propertyKey);
    }
    getVirtualFieldList() {
        return this.getFieldListByKey(this.getVirtualFieldKey());
    }
    setVirtualFieldList(propertyKey) {
        this.setFieldListByKey(this.getVirtualFieldKey(), propertyKey);
    }
    constructor(target){
        _define_property(this, "target", void 0);
        _define_property(this, "metadataFinalized", false);
        this.target = target;
    }
}
class CargoFieldMetadata {
    getKey() {
        return this.key;
    }
    setKey(key) {
        this.key = key;
    }
    getSource() {
        return this.source;
    }
    setSource(source) {
        this.source = source;
    }
    getValidators() {
        return this.validators;
    }
    addValidator(rule) {
        this.validators.push(rule);
    }
    getOptional() {
        return this.optional;
    }
    setOptional(optional) {
        this.optional = optional;
    }
    getDefault() {
        return this.defaultValue;
    }
    setDefault(defaultValue) {
        this.defaultValue = defaultValue;
    }
    getArrayElementType() {
        return this.arrayElementType;
    }
    setArrayElementType(arrayElementType) {
        this.arrayElementType = arrayElementType;
    }
    getTransformer() {
        return this.transformer;
    }
    setTransformer(transformer) {
        this.transformer = transformer;
    }
    getRequestTransformer() {
        return this.requestTransformer;
    }
    setRequestTransformer(transformer) {
        this.requestTransformer = transformer;
    }
    getVirtualTransformer() {
        return this.virtualTransformer;
    }
    setVirtualTransformer(transformer) {
        this.virtualTransformer = transformer;
    }
    setEnumType(enumType) {
        this.enumType = enumType;
    }
    getEnumType() {
        return this.enumType;
    }
    constructor(target, key){
        _define_property(this, "target", void 0);
        _define_property(this, "type", void 0);
        _define_property(this, "key", void 0);
        _define_property(this, "source", void 0);
        _define_property(this, "optional", void 0);
        _define_property(this, "defaultValue", void 0);
        _define_property(this, "arrayElementType", void 0);
        _define_property(this, "validators", void 0);
        _define_property(this, "transformer", void 0);
        _define_property(this, "requestTransformer", void 0);
        _define_property(this, "virtualTransformer", void 0);
        _define_property(this, "enumType", void 0);
        this.target = target;
        this.type = Reflect.getMetadata('design:type', target, key);
        this.key = key;
        this.source = 'body';
        this.validators = [];
        this.optional = false;
        this.defaultValue = undefined;
        this.transformer = undefined;
        this.requestTransformer = undefined;
        this.virtualTransformer = undefined;
        this.enumType = undefined;
    }
}