@trapi/metadata 0.1.2 → 0.1.6

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

package/src/decorator/type.ts

@@ -1,235 +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.
- */
-
-export namespace Decorator {
-    export interface Data {
-        text: string;
-        arguments: any[];
-        typeArguments: any[];
-    }
-
-    // -------------------------------------------
-
-    export interface Config {
-        /**
-         * Use a pre defined third party TypeRepresentationMap in full scope or
-         * only use a partial amount of defined type representations.
-         *
-         * Default: []
-         */
-        library?: ConfigLibrary;
-        /**
-         * Use all internal defined type representations or only use a subset.
-         * Default: true
-         */
-        internal?: TypeRepresentationConfig;
-        /**
-         * Set up self defined type representations.
-         */
-        map?: Partial<TypeRepresentationMap>;
-    }
-
-    // -------------------------------------------
-
-    /**
-     * These are the current by default supported third party libraries.
-     */
-    export type Library = 'typescript-rest' | 'decorators-express';
-    export type ConfigLibrary = Library | Library[] | Record<string, TypeRepresentationConfig>;
-
-    // -------------------------------------------
-
-    /**
-     * Activate/Deactivate specific type representations of a TypeRepresentationMap.
-     */
-    export type TypeRepresentationConfig = boolean | Type | Type[] | { [K in Type]?: boolean };
-
-    // -------------------------------------------
-
-    /**
-     * This type maps a decorator type to its representation config.
-     */
-    export type TypeRepresentationMap = {
-        [T in keyof TypePropertyMap]: Representation<T> | Array<Representation<T>>;
-    };
-
-    /**
-     * The id property is the name/text of the defined decorator.
-     */
-    export interface Representation<T extends keyof TypePropertyMap> {
-        id: string;
-        properties?: RepresentationProperties<TypePropertyMap[T]>;
-    }
-
-    export type RepresentationProperties<P> = {
-        [K in keyof P]: Property
-    };
-
-
-    /**
-     * A decorator type is an identifier which is associated
-     * to specific decorator names.
-     */
-
-    export interface TypePropertyMap {
-        // Class Type
-        SWAGGER_TAGS: {
-            DEFAULT: string[]
-        };
-        CLASS_PATH: {
-            DEFAULT: string
-        };
-
-        // Method and Class
-        REQUEST_ACCEPT: undefined;
-        RESPONSE_EXAMPLE: {
-            TYPE: unknown,
-            PAYLOAD: unknown | unknown[]
-        };
-        RESPONSE_DESCRIPTION: {
-            TYPE: unknown;
-            STATUS_CODE: number | string;
-            DESCRIPTION: string;
-            PAYLOAD: unknown | unknown[];
-        };
-        REQUEST_CONSUMES: {
-            DEFAULT: string[]
-        };
-        RESPONSE_PRODUCES: {
-            DEFAULT: string[]
-        };
-        HIDDEN: {};
-        EXTENSION: {
-            KEY: string,
-            VALUE: unknown | unknown[]
-        };
-
-        // Method
-        METHOD_PATH: {
-            DEFAULT: string
-        };
-        DEPRECATED: undefined;
-
-        // METHOD HTTP
-        ALL: {
-            DEFAULT?: string
-        };
-        GET: {
-            DEFAULT?: string
-        };
-        POST: {
-            DEFAULT?: string
-        };
-        PUT: {
-            DEFAULT?: string
-        };
-        DELETE: {
-            DEFAULT?: string
-        };
-        PATCH: {
-            DEFAULT?: string
-        };
-        OPTIONS: {
-            DEFAULT?: string
-        };
-        HEAD: {
-            DEFAULT?: string
-        };
-
-        // Parameter
-        IS_INT: undefined;
-        IS_LONG: undefined;
-        IS_FlOAT: undefined;
-        IS_DOUBLE: undefined;
-
-        // Parameter Server
-        SERVER_CONTEXT: {};
-        SERVER_PARAMS: {
-            // typescript-rest
-            DEFAULT?: string
-        };
-        SERVER_QUERY: {
-            // typescript-rest
-            DEFAULT?: string,
-            OPTIONS?: Record<string, any>
-        } | undefined;
-        SERVER_FORM: {
-            // typescript-rest
-            DEFAULT?: string
-        } | undefined;
-        SERVER_BODY: {
-            // typescript-rest
-            DEFAULT?: string
-        };
-        SERVER_HEADERS: {
-            // typescript-rest
-            DEFAULT?: string
-        };
-        SERVER_COOKIES: {
-            // typescript-rest
-            DEFAULT?: string
-        };
-        SERVER_PATH_PARAMS: {
-            // typescript-rest
-            DEFAULT?: string
-        };
-        SERVER_FILE_PARAM: {
-            // typescript-rest
-            DEFAULT?: string
-        };
-        SERVER_FILES_PARAM: {
-            // typescript-rest
-            DEFAULT?: string
-        };
-    }
-
-    export type Type = keyof TypePropertyMap;
-
-    export type MethodHttpVerbType = Extract<Type, 'ALL' | 'GET' | 'POST' | 'PUT' | 'DELETE' |
-        'PATCH' | 'OPTIONS' | 'HEAD'>;
-
-
-    export type ParameterServerType = Extract<Type, 'SERVER_CONTEXT' | 'SERVER_PARAMS' | 'SERVER_QUERY' | 'SERVER_FORM' |
-        'SERVER_BODY' | 'SERVER_HEADERS' | 'SERVER_COOKIES' | 'SERVER_PATH_PARAMS' |
-        'SERVER_FILE_PARAM' | 'SERVER_FILES_PARAM'>;
-
-    // -------------------------------------------
-
-    export type PropertyStrategy = 'merge' | 'none' | ((...items: unknown[] | unknown[][]) => unknown | unknown[]);
-
-    export interface Property {
-        /**
-         * Default: 'element'
-         */
-        type?: 'element' | 'array';
-
-        /**
-         * Default: false
-         */
-        isType?: boolean;
-
-        /**
-         * Default: 'argument'
-         */
-        srcArgumentType?: 'argument' | 'typeArgument';
-
-        /**
-         * Default: 0
-         */
-        srcPosition?: number;
-
-        /**
-         * Default: undefined
-         */
-        srcAmount?: number;
-
-        /**
-         * Default: 'none'
-         */
-        srcStrategy?: PropertyStrategy
-    }
-}

package/src/decorator/utils/index.ts

@@ -1,9 +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.
- */
-
-export * from './node';
-export * from './validator';

package/src/decorator/utils/node.ts

@@ -1,59 +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 {isCallExpression, isNumericLiteral, isStringLiteral, Node} from 'typescript';
-import {Decorator} from "../type";
-
-/**
- * Get Decorators for a specific node.
- *
- * @param node
- * @param isMatching
- */
-export function getNodeDecorators(
-    node: Node,
-    isMatching?: (data: Decorator.Data) => boolean
-): Decorator.Data[] {
-    const decorators = node.decorators;
-    if (!decorators || !decorators.length) {
-        return [];
-    }
-
-    const items = decorators
-        .map(d => {
-            const result: any = {
-                arguments: [],
-                typeArguments: []
-            };
-
-            let x: any = d.expression;
-
-            if (isCallExpression(x)) {
-                if (x.arguments) {
-                    result.arguments = x.arguments.map((argument: any) => {
-                        if (isStringLiteral(argument) || isNumericLiteral(argument)) {
-                            return argument.text;
-                        } else {
-                            return argument;
-                        }
-                    });
-                }
-
-                if (x.typeArguments) {
-                    result.typeArguments = x.typeArguments;
-                }
-
-                x = x.expression;
-            }
-
-            result.text = x.text || x.name.text;
-
-            return result as Decorator.Data;
-        });
-
-    return typeof isMatching === 'undefined' ? items : items.filter(isMatching);
-}

package/src/decorator/utils/validator.ts

@@ -1,104 +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 {array, boolean, lazy, mixed, number, object, SchemaOf, string} from "yup";
-import {mapYupRuleForDictionary} from "@trapi/metadata-utils";
-import {Decorator} from "../type";
-
-let validatorInstance : undefined | SchemaOf<Decorator.Config>;
-
-export function useDecoratorConfigValidator() : SchemaOf<Decorator.Config> {
-    if(typeof validatorInstance !== 'undefined') {
-        return validatorInstance;
-    }
-
-    const configMappingOptionValidator : SchemaOf<Decorator.TypeRepresentationConfig> = lazy(value => {
-        if(typeof value === 'boolean') {
-            return boolean();
-        }
-
-        if(typeof value === 'string') {
-            return string();
-        }
-
-        if(Array.isArray(value)) {
-            return array().of(string());
-        }
-
-        if(Object.prototype.toString.call(value) === '[object Object]') {
-            // todo: setup type key check :)
-            return object(mapYupRuleForDictionary(value, boolean())).optional().default({});
-        }
-
-        return mixed().optional().default(undefined);
-    }) as unknown as SchemaOf<Decorator.TypeRepresentationConfig>;
-
-    const useLibraryValidator : SchemaOf<Decorator.ConfigLibrary> = lazy(value => {
-        if(typeof value === 'string') {
-            return string();
-        }
-
-        if(Array.isArray(value)) {
-            return array().of(string());
-        }
-
-        if(Object.prototype.toString.call(value) === '[object Object]') {
-            // todo: setup library key check :)
-            return object(mapYupRuleForDictionary(value, configMappingOptionValidator));
-        }
-
-        return mixed().optional().default(undefined);
-    }) as unknown as SchemaOf<Decorator.ConfigLibrary>;
-
-    const representationPropertyValidator : SchemaOf<Decorator.Property> = object({
-        type: mixed().oneOf(['element', 'array'] as Array<Decorator.Property['type']>),
-        isType: boolean().optional().default(undefined),
-        srcArgumentType: mixed().oneOf(['argument', 'typeArgument'] as Array<Decorator.Property['srcArgumentType']>),
-        srcPosition: number().min(0).optional().default(0),
-        srcAmount: number().optional().default(undefined),
-        // todo: check if 'merge', 'none' or function
-        srcStrategy: mixed().optional().default(undefined),
-    });
-
-    const representationValidator : SchemaOf<Decorator.Representation<any>> = object({
-        id: string().required(),
-        properties: lazy(value => {
-            if(Object.prototype.toString.call(value) === '[object Object]') {
-                return object(mapYupRuleForDictionary(value, representationPropertyValidator)).optional().default({});
-            }
-
-            return mixed().optional().default(undefined);
-        })
-    }) as unknown as SchemaOf<Decorator.Representation<any>>;
-
-    const overrideValidator : SchemaOf<Decorator.TypeRepresentationMap> = lazy(value => {
-        if(Object.prototype.toString.call(value) === '[object Object]') {
-            return object(mapYupRuleForDictionary(value, lazy(val => {
-                    if (Array.isArray(val)) {
-                        return array().of(representationValidator);
-                    }
-
-                    return representationValidator;
-                }))
-            );
-        }
-
-        return mixed().optional().default(undefined);
-    }) as unknown as SchemaOf<Decorator.TypeRepresentationMap>;
-
-
-    validatorInstance = object({
-        library: useLibraryValidator,
-        internal: configMappingOptionValidator,
-        map: overrideValidator
-    }).optional().default({
-        library: ['typescript-rest', '@decorators/express'],
-        internal: true
-    } as Decorator.Config);
-
-    return validatorInstance;
-}

package/src/generator/controller.ts

@@ -1,65 +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 {ClassDeclaration, MethodDeclaration, SyntaxKind} from 'typescript';
-import {EndpointGenerator} from './endpoint';
-import {MetadataGenerator} from './index';
-import {MethodGenerator} from './method';
-import {Controller, Method} from "../type";
-
-export class ControllerGenerator extends EndpointGenerator<ClassDeclaration> {
-    private genMethods: Set<string> = new Set<string>();
-
-    // --------------------------------------------------------------------
-
-    constructor(node: ClassDeclaration, current: MetadataGenerator) {
-        super(node, current);
-
-        this.generatePath('CLASS_PATH');
-    }
-    public isValid() {
-        return !!this.path || this.path === '';
-    }
-
-    public generate(): Controller {
-        if (!this.node.parent) { throw new Error('Controller node doesn\'t have a valid parent source file.'); }
-        if (!this.node.name) { throw new Error('Controller node doesn\'t have a valid name.'); }
-
-        const sourceFile = this.node.parent.getSourceFile();
-
-        return {
-            consumes: this.getConsumes(),
-            location: sourceFile.fileName,
-            methods: this.buildMethods(),
-            name: this.getCurrentLocation(),
-            path: this.path || '',
-            produces: this.getProduces(),
-            responses: this.getResponses(),
-            security: this.getSecurity(),
-            tags: this.getTags(),
-        };
-    }
-
-    protected getCurrentLocation(): string {
-        return (this.node as ClassDeclaration).name.text;
-    }
-
-    private buildMethods() : Method[] {
-        return this.node.members
-            .filter((method: { kind: unknown; }) => (method.kind === SyntaxKind.MethodDeclaration))
-            .filter((method: MethodDeclaration) => !this.isHidden(method))
-            .map((method: MethodDeclaration) => new MethodGenerator(method, this.current,this.path || ''))
-            .filter((generator: MethodGenerator) => {
-                if (generator.isValid() && !this.genMethods.has(generator.getMethodName())) {
-                    this.genMethods.add(generator.getMethodName());
-                    return true;
-                }
-                return false;
-            })
-            .map((generator: MethodGenerator) => generator.generate());
-    }
-}