@trapi/metadata 0.1.4 → 0.1.5

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

package/src/generator/endpoint.ts

@@ -1,212 +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.
- */
-
-'use strict';
-
-import {ArrayLiteralExpression, isArrayLiteralExpression, Node, TypeNode} from 'typescript';
-import {normalizePath} from "@trapi/metadata-utils";
-
-import {Decorator} from "../decorator";
-import {MetadataGenerator} from './index';
-import {getInitializerValue, TypeNodeResolver} from '../resolver';
-import {isExistJSDocTag} from "../utils";
-import {Response} from "../type";
-import {getNodeDecorators} from "../decorator";
-
-export abstract class EndpointGenerator<T extends Node> {
-    protected path: string | undefined;
-    protected node: T;
-
-    // -------------------------------------------
-
-    protected constructor(node: T, protected current: MetadataGenerator) {
-        this.node = node;
-    }
-
-    // --------------------------------------------------------------------
-
-    protected generatePath(
-        key: Extract<Decorator.Type, 'CLASS_PATH' | 'METHOD_PATH'>
-    ) : void {
-        const values : string[] = [];
-
-        const representation = this.current.decoratorMapper.match(key, this.node);
-        if(typeof representation !== 'undefined') {
-            const value = representation.getPropertyValue('DEFAULT');
-            if(typeof value !== 'undefined') {
-                values.push(value);
-            }
-        }
-
-        this.path = normalizePath(values.join('/'));
-    }
-
-    // --------------------------------------------------------------------
-
-    protected getDecoratorValues(decoratorName: string, acceptMultiple: boolean = false) : any[] {
-        const decorators = getNodeDecorators(this.node, decorator => decorator.text === decoratorName);
-
-        if (!decorators || !decorators.length) { return []; }
-
-        if (!acceptMultiple && decorators.length > 1) {
-            throw new Error(`Only one ${decoratorName} decorator allowed in ${this.getCurrentLocation()}.`);
-        }
-
-        let result: any[];
-
-        if (acceptMultiple) {
-            result = decorators.map(d => d.arguments);
-        } else {
-            const d = decorators[0];
-            result = d.arguments;
-        }
-
-        return result;
-    }
-
-    // -------------------------------------------
-
-    protected getSecurity() {
-        const securities = this.getDecoratorValues('Security', true);
-        if (!securities || !securities.length) { return undefined; }
-
-        return securities.map(security => {
-            const rolesArray : string[] = security[0] ? this.handleRolesArray(security[0]) : [];
-
-            return {
-                name: security[1] ? security[1] : 'default',
-                scopes: rolesArray
-            };
-        });
-    }
-
-    protected handleRolesArray(argument: ArrayLiteralExpression): string[] {
-        if (isArrayLiteralExpression(argument)) {
-            return argument.elements.map(value => value.getText())
-                .map(val => (val && val.startsWith('\'') && val.endsWith('\'')) ? val.slice(1, -1) : val);
-        } else {
-            return argument;
-        }
-    }
-
-    // -------------------------------------------
-
-    protected getExamplesValue(argument: any) : unknown[] {
-        let example: any = {};
-
-        if(typeof argument === 'undefined') {
-            return example;
-        }
-
-        if (argument.properties) {
-            argument.properties.forEach((p: any) => {
-                example[p.name.text] = getInitializerValue(p.initializer, this.current.typeChecker);
-            });
-        } else {
-            example = getInitializerValue(argument, this.current.typeChecker);
-        }
-
-        return example;
-    }
-
-    // -------------------------------------------
-
-    protected getResponses(): Response[] {
-        const representation = this.current.decoratorMapper.match('RESPONSE_DESCRIPTION', this.node);
-        if(typeof representation === 'undefined') {
-            return [];
-        }
-
-        const responses : Response[] = [];
-
-        for(let i=0; i<representation.decorators.length; i++) {
-            const description = representation.getPropertyValue('DESCRIPTION', i) || 'Ok';
-            const status = representation. getPropertyValue('STATUS_CODE', i) || '200';
-            let examples : unknown | unknown[] = representation. getPropertyValue('PAYLOAD', i);
-
-            const type = representation.getPropertyValue('TYPE');
-
-            const response : Response = {
-                description: description,
-                examples: examples,
-                schema: type ? new TypeNodeResolver(type as TypeNode, this.current).resolve() : undefined,
-                status: status as string,
-                name: status as string
-            };
-
-            responses.push(response);
-        }
-
-        return responses;
-    }
-
-    // -------------------------------------------
-
-    public getProduces() : string[] {
-        const representation = this.current.decoratorMapper.match('RESPONSE_PRODUCES', this.node);
-        if(typeof representation === 'undefined') {
-            return [];
-        }
-
-        const value : string[] = representation.getPropertyValue('DEFAULT');
-        if(typeof value === 'undefined') {
-            return [];
-        }
-
-        return Array.isArray(value) ? value : [value];
-    }
-
-    public getConsumes() : string[] {
-        const representation = this.current.decoratorMapper.match('REQUEST_CONSUMES', this.node);
-        if(typeof representation === 'undefined') {
-            return [];
-        }
-
-        let value : string[] = representation.getPropertyValue('DEFAULT');
-        if(typeof value === 'undefined') {
-            return [];
-        }
-
-        value = Array.isArray(value) ? value : [value];
-
-        return value;
-    }
-
-    public getTags() : string[] {
-        const representation = this.current.decoratorMapper.match('SWAGGER_TAGS', this.node);
-        if(typeof representation === 'undefined') {
-            return [];
-        }
-
-        let value : string[] = representation.getPropertyValue('DEFAULT');
-        if(typeof value === 'undefined') {
-            return [];
-        }
-
-        value = Array.isArray(value) ? value : [value];
-
-        return value;
-    }
-
-    // -------------------------------------------
-
-    protected abstract getCurrentLocation(): string;
-
-    // -------------------------------------------
-
-    public isHidden(node: Node) : boolean {
-        return typeof this.current.decoratorMapper.match('HIDDEN', node) !== 'undefined';
-    }
-
-    public isDeprecated(node: Node) : boolean {
-        if (isExistJSDocTag(node, tag => tag.tagName.text === 'deprecated')) {
-            return true;
-        }
-
-        return typeof this.current.decoratorMapper.match('DEPRECATED', node) !== 'undefined';
-    }
-}