@trapi/metadata 0.1.1 → 0.1.5

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];
-
-    }
-}
-

package/src/decorator/representation/property/utils.ts

@@ -1,146 +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 {
-    Expression
-} from "typescript";
-import {hasOwnProperty} from "@trapi/metadata-utils";
-import {Decorator} from "../../type";
-import {getInitializerValue} from "../../../resolver";
-
-export function extendRepresentationPropertyConfig(property: Decorator.Property): Decorator.Property {
-    if(typeof property.isType === 'undefined') {
-        property.isType = false;
-    }
-
-    if (typeof property.type === 'undefined') {
-        property.type = 'element';
-    }
-
-    if (typeof property.srcArgumentType === 'undefined') {
-        property.srcArgumentType = 'argument';
-    }
-
-    if (
-        property.type === 'element' &&
-        typeof property.srcPosition === 'undefined'
-    ) {
-        property.srcPosition = 0;
-    }
-
-    return property;
-}
-
-export function extractRepresentationPropertyValue<
-    T extends Decorator.Type,
-    P extends keyof Decorator.TypePropertyMap[T]
-    >(
-    decorator: Decorator.Data,
-    config: Decorator.Property
-): Decorator.TypePropertyMap[T][P] | undefined {
-    let items : unknown[] = [];
-
-    switch (config.srcArgumentType) {
-        case 'typeArgument':
-            items = decorator.typeArguments;
-            break;
-        case "argument":
-            items = decorator.arguments;
-            break;
-    }
-
-    if(!config.isType) {
-        items = extractValueFromArgumentType(items);
-    }
-
-    const srcPosition : number = config.srcPosition ?? 0;
-    const srcAmount : number = config.srcAmount ?? 1;
-
-    if (items.length <= srcPosition) {
-        switch (config.type) {
-            case 'element':
-                return undefined;
-            case 'array':
-                return [] as unknown as Decorator.TypePropertyMap[T][P];
-        }
-    }
-
-    const data : unknown[] | unknown[][] = srcAmount >= 1 ? items.slice(srcPosition, srcPosition + srcAmount) : items.slice(srcPosition);
-
-    if(data.length === 0) {
-        return (config.type === 'array' ? [] : undefined) as unknown as Decorator.TypePropertyMap[T][P];
-    }
-
-    const srcStrategy : Decorator.PropertyStrategy = config.srcStrategy ?? 'none';
-
-    switch (srcStrategy) {
-        case "merge":
-            switch (config.type) {
-                case 'array':
-                    return mergeArrayArguments(data) as unknown as Decorator.TypePropertyMap[T][P];
-                case 'element':
-                default:
-                    return mergeObjectArguments(data) as Decorator.TypePropertyMap[T][P];
-            }
-        case "none":
-            // if we dont have any merge strategy, we just return the first argument.
-            switch (config.type) {
-                case 'array':
-                    const arr = Array.isArray(data[0]) ? data[0] : [data[0]];
-                    return arr as unknown as Decorator.TypePropertyMap[T][P];
-                case 'element':
-                default:
-                    return data[0] as Decorator.TypePropertyMap[T][P];
-            }
-        default:
-            if(typeof config.srcStrategy === 'function') {
-                return config.srcStrategy(data) as Decorator.TypePropertyMap[T][P];
-            }
-
-            return (config.type === 'array' ? [] : undefined) as unknown as Decorator.TypePropertyMap[T][P];
-    }
-}
-
-export function mergeObjectArguments(data: unknown[]) {
-    let output : Record<string, any> = {};
-    for(let i=0; i<data.length; i++) {
-        const prototype = Object.prototype.toString.call(data[i]);
-        if(prototype === '[object Object]') {
-            output = Object.assign(output, data[i]);
-        }
-    }
-
-    return output;
-}
-
-export function mergeArrayArguments(data: unknown[]) {
-    let merged : unknown[] = [];
-    for(let i=0; i<data.length; i++) {
-        if(Array.isArray(data[i])) {
-            merged = [...merged, ...data[i] as unknown[]];
-        } else {
-            merged.push(data[i]);
-        }
-    }
-
-    return merged;
-}
-
-function extractValueFromArgumentType(argument: unknown[]) {
-    const values : unknown[] = [];
-
-    for(let i=0; i<argument.length; i++) {
-        if(!hasOwnProperty(argument[i], 'kind')) {
-            values.push(argument[i]);
-            continue;
-        }
-
-        values.push(getInitializerValue(argument[i] as Expression));
-    }
-
-    return values;
-}