@trapi/metadata 0.1.2 → 0.1.6

package/src/decorator/mapper/index.ts

@@ -1,153 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {Node} from "typescript";
-import {hasOwnProperty} from "@trapi/metadata-utils";
-import {RepresentationManager} from "../representation";
-import {Decorator} from "../type";
-import {getDecoratorMap, isMappingTypeIncluded, reduceTypeRepresentationMapping} from "./utils";
-import {getNodeDecorators} from "../utils";
-
-export class DecoratorMapper {
-    protected mapping : Partial<Decorator.TypeRepresentationMap> = {};
-
-    constructor(
-        protected config?: Decorator.Config
-    ) {
-        this.aggregate();
-    }
-
-    public setConfig(config?: Decorator.Config) {
-        this.config = config;
-        this.aggregate();
-    }
-
-    /**
-     * Try to find a matching representation for a given decorator type and decorators or node.
-     *
-     * @param type
-     * @param data
-     */
-    public match<T extends Decorator.Type>(
-        type: T,
-        data: Decorator.Data[] | Node
-    ) {
-        if(!hasOwnProperty(this.mapping, type)) {
-            return undefined;
-        }
-
-        const decorators : Decorator.Data[] = Array.isArray(data) ? data : getNodeDecorators(data);
-
-        const representations : Array<Decorator.Representation<T>> = (Array.isArray(this.mapping[type]) ? this.mapping[type] : [this.mapping[type]]) as Array<Decorator.Representation<T>>;
-        for(let i=0; i<representations.length; i++) {
-            const items = decorators.filter(decorator => decorator.text === representations[i].id);
-            if(items.length > 0) {
-                return new RepresentationManager<T>(
-                    representations[i],
-                    items
-                );
-            }
-        }
-
-        return undefined;
-    }
-
-    // -------------------------------------------
-
-    private aggregate() : void {
-        if(typeof this.config === 'undefined') {
-            this.mapping = {};
-            return;
-        }
-
-        const items : Array<Partial<Decorator.TypeRepresentationMap>> = [];
-
-        // mapping - internal
-        const internalMap = getDecoratorMap('internal');
-        items.push(
-            typeof this.config.internal === 'undefined' ?
-                internalMap :
-                reduceTypeRepresentationMapping(internalMap, (type) => {
-                    return isMappingTypeIncluded(type, this.config.internal);
-                })
-        );
-
-        // mapping - extension
-        if(typeof this.config.map !== 'undefined') {
-            items.push(this.config.map);
-        }
-
-        // mapping - library
-        if(typeof this.config.library !== 'undefined') {
-            // check if string or string[]
-
-            if(
-                typeof this.config.library === 'string' ||
-                Array.isArray(this.config.library)
-            ) {
-                const libraries : string[] = Array.isArray(this.config.library) ?
-                    this.config.library :
-                    [this.config.library];
-
-                items.push(...libraries.map(library => getDecoratorMap(library)));
-            } else {
-                // tslint:disable-next-line:forin
-                for(const key in this.config.library) {
-                    items.push(
-                        reduceTypeRepresentationMapping(getDecoratorMap(key), (type) => {
-                            return isMappingTypeIncluded(type, this.config.library[key]);
-                        })
-                    );
-                }
-            }
-        }
-
-        this.mapping = this.merge(...items);
-    }
-
-    /**
-     * Merge decorator type-representation mappings of different libraries together.
-     *
-     * @param mappings
-     * @private
-     */
-    private merge(...mappings: Array<Partial<Decorator.TypeRepresentationMap>>) : Partial<Decorator.TypeRepresentationMap> {
-        const result : Partial<Decorator.TypeRepresentationMap> = {};
-
-        // we need all available mapping keys :)
-        let keys : Decorator.Type[] = mappings
-            .map(mapping => Object.keys(mapping))
-            .reduce(((previousValue, currentValue) => [...previousValue, ...currentValue])) as Decorator.Type[];
-
-        keys = Array.from(new Set(keys));
-
-        for(let i=0; i<keys.length; i++) {
-            const representations : Array<Decorator.Representation<any>> = [];
-
-            for(let j=0; j<mappings.length; j++) {
-                if(hasOwnProperty(mappings[j], keys[i])) {
-                    const value : Decorator.Representation<any> | Array<Decorator.Representation<any>> = mappings[j][keys[i]];
-
-                    if(typeof value === 'undefined') {
-                        continue;
-                    }
-
-                    if(Array.isArray(value)) {
-                        representations.push(...value);
-                    } else {
-                        representations.push(value);
-                    }
-                }
-            }
-
-            // @ts-ignore
-            result[keys[i]] = representations;
-        }
-
-        return result;
-    }
-}

package/src/decorator/mapper/maps/decorators-express.ts

@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {Decorator} from "../../type";
-
-export default {
-    // Class
-    CLASS_PATH: {
-        id: 'Controller',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-
-    // Method
-    METHOD_PATH: [
-        {
-            id: 'All',
-            properties: {
-                DEFAULT: {}
-            }
-        },
-        {
-            id: 'Get',
-            properties: {
-                DEFAULT: {}
-            }
-        },
-        {
-            id: 'Post',
-            properties: {
-                DEFAULT: {}
-            }
-        },
-        {
-            id: 'Put',
-            properties: {
-                DEFAULT: {}
-            }
-        },
-        {
-            id: 'Delete',
-            properties: {
-                DEFAULT: {}
-            }
-        },
-        {
-            id: 'Patch',
-            properties: {
-                DEFAULT: {}
-            }
-        },
-        {
-            id: 'Options',
-            properties: {
-                DEFAULT: {}
-            }
-        },
-        {
-            id: 'Head',
-            properties: {
-                DEFAULT: {}
-            }
-        }
-    ],
-
-    // Parameter
-    SERVER_CONTEXT: [
-        {
-            id: 'Request',
-            properties: {}
-        },
-        {
-            id: 'Response',
-            properties: {}
-        },
-        {
-            id: 'Next',
-            properties: {}
-        },
-    ],
-    SERVER_QUERY: {
-        id: 'Query',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_FORM: undefined,
-    SERVER_BODY: {
-        id: 'Body',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_HEADERS: {
-        id: 'Headers',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_COOKIES: {
-        id: 'Cookies',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_PATH_PARAMS: {
-        id: 'Params',
-        properties: {
-            DEFAULT: {}
-        }
-    }
-} as Partial<Decorator.TypeRepresentationMap>;

package/src/decorator/mapper/maps/internal.ts

@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {Decorator} from "../../type";
-
-export default {
-    EXTENSION: {
-        id: 'Extension',
-        properties: {
-            KEY: {type: "element", srcArgumentType: "argument", srcPosition: 0},
-            VALUE: {type: "element", srcArgumentType: "argument", srcPosition: 1}
-        }
-    },
-
-    // Class
-    SWAGGER_TAGS: {
-        id: 'SwaggerTags',
-        properties: {
-            DEFAULT: {type: 'array', srcArgumentType: "argument"}
-        }
-    },
-
-    // Class + Method
-    RESPONSE_EXAMPLE: {
-        id: 'ResponseExample',
-        properties: {
-            TYPE: {isType: true, srcArgumentType: "typeArgument"},
-            PAYLOAD: {type: "element", srcArgumentType: "argument", srcPosition: 0}
-        }
-    },
-    RESPONSE_DESCRIPTION: {
-        id: 'ResponseDescription',
-        properties: {
-            TYPE: {isType: true, srcArgumentType: "typeArgument"},
-            STATUS_CODE: {type: "element", srcArgumentType: "argument", srcPosition: 0},
-            DESCRIPTION: {type: "element", srcArgumentType: "argument", srcPosition: 1},
-            PAYLOAD: {type: "element", srcArgumentType: "argument", srcPosition: 2}
-        }
-    },
-    REQUEST_CONSUMES: {
-        id: 'RequestConsumes',
-        properties: {
-            DEFAULT: {type: 'array', srcArgumentType: "argument", srcAmount: -1, srcStrategy: "merge"}
-        }
-    },
-    RESPONSE_PRODUCES: {
-        id: 'ResponseProduces',
-        properties: {
-            DEFAULT: {type: 'array', srcArgumentType: "argument", srcAmount: -1, srcStrategy: "merge"}
-        }
-    },
-
-    HIDDEN: {
-        id: 'SwaggerHidden',
-        properties: []
-    },
-    DEPRECATED: {
-        id: 'SwaggerDeprecated',
-        properties: undefined
-    },
-
-    IS_INT: {
-        id: 'IsInt',
-        properties: undefined
-    },
-    IS_LONG: {
-        id: 'IsLong',
-        properties: undefined
-    },
-    IS_FlOAT: {
-        id: 'IsFloat',
-        properties: undefined
-    },
-    IS_DOUBLE: {
-        id: 'IsDouble',
-        properties: undefined
-    },
-
-    SERVER_FILES_PARAM: {
-        id: 'RequestFileParam',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_FILE_PARAM: {
-        id: 'RequestFileParam',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-} as Partial<Decorator.TypeRepresentationMap>;

package/src/decorator/mapper/maps/typescript-rest.ts

@@ -1,150 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {Decorator} from "../../type";
-
-export default {
-    // Class
-    CLASS_PATH: {
-        id: 'Path',
-        properties: {
-            DEFAULT: {type: 'element', srcArgumentType: "argument"}
-        }
-    },
-
-    // Class + Method
-    REQUEST_ACCEPT: undefined,
-    RESPONSE_EXAMPLE: {
-        id: 'Example',
-        properties: {
-            TYPE: {isType: true, srcArgumentType: "typeArgument"},
-            PAYLOAD: {type: "element", srcArgumentType: "argument"}
-        }
-    },
-    RESPONSE_DESCRIPTION: {
-        id: 'Response',
-        properties: {
-            TYPE: {type: "element", srcArgumentType: "typeArgument"},
-            STATUS_CODE: {type: "element", srcArgumentType: "argument", srcPosition: 0},
-            DESCRIPTION: {type: "element", srcArgumentType: "argument", srcPosition: 1},
-            PAYLOAD: {type: "element", srcArgumentType: "argument", srcPosition: 2}
-        }
-    },
-
-    // Method
-    ALL: {
-        id: 'ALL',
-        properties: {}
-    },
-    GET: {
-        id: 'GET',
-        properties: {}
-    },
-    POST: {
-        id: 'POST',
-        properties: {}
-    },
-    PUT: {
-        id: 'PUT',
-        properties: {}
-    },
-    DELETE: {
-        id: 'DELETE',
-        properties: {}
-    },
-    PATCH: {
-        id: 'PATCH',
-        properties: {}
-    },
-    OPTIONS: {
-        id: 'OPTIONS',
-        properties: {}
-    },
-    HEAD: {
-        id: 'HEAD',
-        properties: {}
-    },
-
-    METHOD_PATH: {
-        id: 'Path',
-        properties: {
-            DEFAULT: {type: 'element', srcArgumentType: "argument"}
-        }
-    },
-
-    // Parameter
-    SERVER_CONTEXT: [
-        {
-            id: 'Context',
-        },
-        {
-            id: 'ContextRequest',
-        },
-        {
-            id: 'ContextResponse',
-        },
-        {
-            id: 'ContextNext',
-        },
-        {
-            id: 'ContextLanguage',
-        },
-        {
-            id: 'ContextAccept',
-        }
-    ],
-    SERVER_PARAMS: {
-        id: 'Param',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_QUERY: {
-        id: 'QueryParam',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_FORM: {
-        id: 'FormParam',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_BODY: undefined,
-    SERVER_HEADERS: {
-        id: 'HeaderParam',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_COOKIES: {
-        id: 'CookieParam',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_PATH_PARAMS: {
-        id: 'PathParam',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_FILES_PARAM: {
-        id: 'FilesParam',
-        properties: {
-            DEFAULT: {}
-        }
-    },
-    SERVER_FILE_PARAM: {
-        id: 'FileParam',
-        properties: {
-            DEFAULT: {}
-        }
-    }
-} as Partial<Decorator.TypeRepresentationMap>;
-

package/src/decorator/mapper/utils.ts

@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {hasOwnProperty} from "@trapi/metadata-utils";
-import {Decorator} from "../type";
-
-/**
- *
- *
- * @param mapping
- * @param reducer
- */
-export function reduceTypeRepresentationMapping(
-    mapping: Partial<Decorator.TypeRepresentationMap>,
-    reducer: (type: Decorator.Type) => boolean
-): Partial<Decorator.TypeRepresentationMap> {
-    const mappingKeys: Decorator.Type[] = (Object.keys(mapping) as Decorator.Type[]);
-    const allowedTypes: Decorator.Type[] = mappingKeys
-        .filter(reducer);
-
-    if (mappingKeys.length === allowedTypes.length) {
-        return mapping;
-    }
-
-    const result: Partial<Decorator.TypeRepresentationMap> = {};
-    for (let i = 0; i < allowedTypes.length; i++) {
-        // @ts-ignore
-        result[allowedTypes[i]] = mapping[allowedTypes[i]];
-    }
-
-    return result;
-}
-
-/**
- *
- *
- * @param type
- * @param config
- */
-export function isMappingTypeIncluded(
-    type: Decorator.Type,
-    config: Decorator.TypeRepresentationConfig
-): boolean {
-    const allowedType = Object.prototype.toString.call(config);
-    switch (allowedType) {
-        case '[object Boolean]':
-            return !!config;
-        case '[object String]':
-            return (config as string) === type;
-        case '[object Array]':
-            return (config as unknown as Decorator.Type[]).indexOf(type) !== -1;
-        case '[object Object]':
-            return hasOwnProperty((config as Record<Decorator.Type, boolean>), type) && (config as Record<Decorator.Type, boolean>)[type];
-    }
-
-    /* istanbul ignore next */
-    return false;
-}
-
-let decoratorMap : Record<string, Partial<Decorator.TypeRepresentationMap>> = {};
-
-export function getDecoratorMap(name: string) : Partial<Decorator.TypeRepresentationMap> {
-    if(hasOwnProperty(decoratorMap, name)) {
-        return decoratorMap[name];
-    }
-
-    const content = loadDecoratorMap(name);
-
-    (decoratorMap as Record<string, Partial<Decorator.TypeRepresentationMap>>)[name] = content;
-
-    return content;
-}
-
-/* istanbul ignore next */
-function loadDecoratorMap(library: string) : Partial<Decorator.TypeRepresentationMap> {
-    const exp = require(`./maps/${library}`);
-
-    if(hasOwnProperty(exp, 'default')) {
-        return exp.default;
-    }
-
-    /* istanbul ignore next */
-    return exp;
-}

package/src/decorator/representation/index.ts

@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {hasOwnProperty} from "@trapi/metadata-utils";
-import {Decorator} from "../type";
-import {extendRepresentationPropertyConfig, extractRepresentationPropertyValue} from "./property/utils";
-import TypePropertyMaps = Decorator.TypePropertyMap;
-
-export class RepresentationManager<T extends Decorator.Type> {
-    protected extendedProperties : Partial<Decorator.RepresentationProperties<Decorator.TypePropertyMap[T]>> = {};
-
-    constructor(
-        protected representation: Decorator.Representation<T>,
-        public decorators: Decorator.Data[]
-    ) {
-
-    }
-
-    // -------------------------------------------
-
-    /**
-     * Get one or more specific value(s) of the decorator arguments or typeArguments.
-     * @param type
-     * @param decoratorOrIndex
-     */
-    public getPropertyValue<P extends keyof Decorator.TypePropertyMap[T]>(
-        type: P,
-        decoratorOrIndex?: number | Decorator.Data
-    ) : TypePropertyMaps[T][P] | undefined {
-        const config : Decorator.Property = this.getPropertyConfiguration(type);
-        if(typeof config === 'undefined') {
-            return undefined;
-        }
-
-        let decorator : Decorator.Data;
-
-        if(
-            typeof decoratorOrIndex === 'number' ||
-            typeof decoratorOrIndex === 'undefined'
-        ) {
-            decoratorOrIndex = decoratorOrIndex ?? 0;
-            if (decoratorOrIndex < 0 || decoratorOrIndex >= this.decorators.length) {
-                return undefined;
-            }
-
-            decorator = this.decorators[decoratorOrIndex];
-        } else {
-            decorator = decoratorOrIndex;
-        }
-
-        return extractRepresentationPropertyValue<T, P>(decorator, config);
-    }
-
-    // -------------------------------------------
-
-    public getPropertyConfiguration(type: keyof Decorator.TypePropertyMap[T]) : Decorator.Property | undefined {
-        if(!hasOwnProperty(this.representation.properties, type)) {
-            return undefined;
-        }
-
-        return this.extendProperty(type);
-    }
-
-    // -------------------------------------------
-
-    protected extendProperty<P extends keyof Decorator.TypePropertyMap[T]>(type: P) : Decorator.Property {
-        if(hasOwnProperty(this.extendedProperties, type)) {
-            return this.extendedProperties[type];
-        }
-
-        const property = this.representation.properties[type];
-        this.extendedProperties[type] = extendRepresentationPropertyConfig(property);
-
-        return this.extendedProperties[type];
-
-    }
-}
-