@trapi/metadata 0.1.2 → 0.1.6

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

package/src/generator/index.ts

@@ -1,219 +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 {sync} from 'glob';
-import {
-    ClassDeclaration,
-    CompilerOptions,
-    createProgram,
-    forEachChild,
-    InterfaceDeclaration,
-    isModuleBlock,
-    isModuleDeclaration,
-    Node,
-    NodeFlags,
-    Program,
-    SourceFile,
-    SyntaxKind,
-    TypeChecker
-} from 'typescript';
-import {Config, Controller, GeneratorOutput} from "../type";
-import {DecoratorMapper} from "../decorator/mapper";
-import {ControllerGenerator} from './controller';
-import {TypeNodeResolver} from "../resolver";
-import {Resolver} from "../resolver";
-import {CacheDriver} from "../cache/driver";
-
-const minimatch = require("minimatch");
-
-export class MetadataGenerator {
-    public readonly nodes = new Array<Node>();
-    public readonly typeChecker: TypeChecker;
-
-    public readonly decoratorMapper: DecoratorMapper;
-
-    public readonly config: Config;
-
-    private readonly program: Program;
-
-    private cache : CacheDriver;
-    private controllers: Controller[];
-    private referenceTypes: Resolver.ReferenceTypes = {};
-
-    private circularDependencyResolvers = new Array<Resolver.DependencyResolver>();
-
-    // -------------------------------------------------------------------------
-
-    constructor(
-        config: Config,
-        compilerOptions: CompilerOptions
-    ) {
-        this.config = config;
-
-        this.cache = new CacheDriver(config.cache);
-        this.decoratorMapper = new DecoratorMapper(config.decorator);
-
-        TypeNodeResolver.clearCache();
-
-        const sourceFiles = this.scanSourceFiles(config.entryFile);
-        this.program = createProgram(sourceFiles, compilerOptions);
-        this.typeChecker = this.program.getTypeChecker();
-    }
-
-    // -------------------------------------------------------------------------
-
-    public generate(): GeneratorOutput {
-        const sourceFileSize : number = this.buildNodesFromSourceFiles();
-
-        let cache = this.cache.get(sourceFileSize);
-
-        if(!cache) {
-            this.buildControllers();
-
-            this.circularDependencyResolvers.forEach(resolve => resolve(this.referenceTypes));
-
-            cache = {
-                controllers: this.controllers,
-                referenceTypes: this.referenceTypes,
-                sourceFilesSize: sourceFileSize
-            };
-
-            this.cache.save(cache);
-        }
-
-        return {
-            controllers: cache.controllers,
-            referenceTypes: cache.referenceTypes
-        };
-    }
-
-    protected buildNodesFromSourceFiles() : number {
-        let endSize : number = 0;
-
-        this.program.getSourceFiles().forEach((sf: SourceFile) => {
-            const isIgnored : boolean = this.isIgnoredPath(sf.fileName);
-            if(isIgnored) {
-                return;
-            }
-
-            endSize += sf.end;
-
-            forEachChild(sf, (node: any) => {
-                if (isModuleDeclaration(node)) {
-                    /**
-                     * For some reason unknown to me, TS resolves both `declare module` and `namespace` to
-                     * the same kind (`ModuleDeclaration`). In order to figure out whether it's one or the other,
-                     * we check the node flags. They tell us whether it is a namespace or not.
-                     */
-
-                    // tslint:disable-next-line:no-bitwise
-                    if ((node.flags & NodeFlags.Namespace) === 0 && node.body && isModuleBlock(node.body)) {
-                        node.body.statements.forEach(statement => {
-                            this.nodes.push(statement);
-                        });
-                        return;
-                    }
-                }
-
-
-                this.nodes.push(node);
-            });
-        });
-
-        return endSize;
-    }
-
-    // -------------------------------------------------------------------------
-
-    /**
-     * Check if the source file path is in the ignored path list.
-     *
-     * @param filePath
-     * @protected
-     */
-    protected isIgnoredPath(filePath: string) : boolean {
-        if(typeof this.config.ignore === 'undefined') {
-            return false;
-        }
-
-        return this.config.ignore.some(item => minimatch(filePath, item));
-    }
-
-    // -------------------------------------------------------------------------
-
-    public isExportedNode(node: Node) {
-        return true;
-    }
-
-    // -------------------------------------------------------------------------
-
-    public addReferenceType(referenceType: Resolver.ReferenceType) {
-        if (!referenceType.refName) {
-            return;
-        }
-
-        this.referenceTypes[referenceType.refName] = referenceType;
-    }
-
-    public getReferenceType(refName: string) {
-        return this.referenceTypes[refName];
-    }
-
-    public registerDependencyResolver(callback: Resolver.DependencyResolver) {
-        this.circularDependencyResolvers.push(callback);
-    }
-
-    public getClassDeclaration(className: string) {
-        const found = this.nodes
-            .filter(node => {
-                const classDeclaration = (node as ClassDeclaration);
-                return (node.kind === SyntaxKind.ClassDeclaration && classDeclaration.name && classDeclaration.name.text === className);
-            });
-        if (found && found.length) {
-            return found[0];
-        }
-        return undefined;
-    }
-
-    public getInterfaceDeclaration(className: string) {
-        const found = this.nodes
-            .filter(node => {
-                const interfaceDeclaration = (node as InterfaceDeclaration);
-                return (node.kind === SyntaxKind.InterfaceDeclaration && interfaceDeclaration.name && interfaceDeclaration.name.text === className);
-            });
-        if (found && found.length) {
-            return found[0];
-        }
-        return undefined;
-    }
-
-    private scanSourceFiles(sourceFiles: string | string[]) {
-        const sourceFilesExpressions = Array.isArray(sourceFiles) ? sourceFiles : [sourceFiles];
-        const result: Set<string> = new Set<string>();
-        const options = { cwd: process.cwd() };
-        sourceFilesExpressions.forEach(pattern => {
-            const matches = sync(pattern, options);
-            matches.forEach(file => {result.add(file); });
-        });
-
-        return Array.from(result);
-    }
-
-    private buildControllers() : void {
-        this.controllers = this.nodes
-            .filter(node => node.kind === SyntaxKind.ClassDeclaration)
-            .filter(node => {
-                const isHidden = this.decoratorMapper.match('HIDDEN', node);
-
-                return typeof isHidden === 'undefined';
-            })
-            .filter(node => typeof this.decoratorMapper.match('CLASS_PATH', node) !== 'undefined')
-            .map((classDeclaration: ClassDeclaration) => new ControllerGenerator(classDeclaration, this))
-            .filter(generator => generator.isValid())
-            .map(generator => generator.generate());
-    }
-}

package/src/generator/method.ts

@@ -1,198 +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 * as pathUtil from 'path';
-import * as ts from 'typescript';
-import {Decorator} from "../decorator";
-import {EndpointGenerator} from './endpoint';
-import {MetadataGenerator} from './index';
-import {ParameterGenerator} from './parameter';
-import {Resolver, TypeNodeResolver} from "../resolver";
-import {hasOwnProperty} from "@trapi/metadata-utils";
-import {Method, MethodType, Parameter, Response} from "../type";
-import {getJSDocDescription, getJSDocTagComment} from '../utils';
-import MethodHttpVerbKey = Decorator.MethodHttpVerbType;
-import {getNodeDecorators} from "../decorator";
-
-
-export class MethodGenerator extends EndpointGenerator<ts.MethodDeclaration> {
-    private method: MethodType;
-
-    // --------------------------------------------------------------------
-
-    constructor(
-        node: ts.MethodDeclaration,
-        current: MetadataGenerator,
-        private readonly controllerPath: string
-    ) {
-        super(node, current);
-        this.processMethodDecorators();
-    }
-
-    // --------------------------------------------------------------------
-
-    public isValid() {
-        return !!this.method;
-    }
-
-    public getMethodName() {
-        const identifier = this.node.name as ts.Identifier;
-        return identifier.text;
-    }
-
-    public generate(): Method {
-        if (!this.isValid()) { throw new Error('This isn\'t a valid controller method.'); }
-
-        let nodeType = this.node.type;
-        if (!nodeType) {
-            const typeChecker = this.current.typeChecker;
-            const signature = typeChecker.getSignatureFromDeclaration(this.node);
-            const implicitType = typeChecker.getReturnTypeOfSignature(signature!);
-            nodeType = typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation) as ts.TypeNode;
-        }
-
-        const type = new TypeNodeResolver(nodeType, this.current).resolve();
-        const responses = this.mergeResponses(this.getResponses(), this.getMethodSuccessResponse(type));
-
-        return {
-            // todo: implement extensions
-            consumes: this.getConsumes(),
-            deprecated: this.isDeprecated(this.node),
-            description: getJSDocDescription(this.node),
-            extensions: [],
-            hidden: this.isHidden(this.node),
-            method: this.method,
-            name: (this.node.name as ts.Identifier).text,
-            parameters: this.buildParameters(),
-            path: this.path,
-            produces: this.getProduces(),
-            responses: responses,
-            security: this.getSecurity(),
-            summary: getJSDocTagComment(this.node, 'summary'),
-            tags: this.getTags(),
-            type: type
-        };
-    }
-
-    protected getCurrentLocation() {
-        const methodId = this.node.name as ts.Identifier;
-        const controllerId = (this.node.parent as ts.ClassDeclaration).name as ts.Identifier;
-        return `${controllerId.text}.${methodId.text}`;
-    }
-
-    private buildParameters() {
-        const parameters = this.node.parameters.map((p: ts.ParameterDeclaration) => {
-            try {
-                const path = pathUtil.posix.join('/', (this.controllerPath ? this.controllerPath : ''), this.path);
-
-                return new ParameterGenerator(p, this.method, path, this.current).generate();
-            } catch (e) {
-                const methodId = this.node.name as ts.Identifier;
-                const controllerId = (this.node.parent as ts.ClassDeclaration).name as ts.Identifier;
-                const parameterId = p.name as ts.Identifier;
-                throw new Error(`Error generate parameter method: '${controllerId.text}.${methodId.text}' argument: ${parameterId.text} ${e}`);
-            }
-        }).filter((p: Parameter) => (p.in !== 'context') && (p.in !== 'cookie'));
-
-        const bodyParameters = parameters.filter((p: Parameter) => p.in === 'body');
-        const formParameters = parameters.filter((p: Parameter) => p.in === 'formData');
-
-        if (bodyParameters.length > 1) {
-            throw new Error(`Only one body parameter allowed in '${this.getCurrentLocation()}' method.`);
-        }
-
-        if (bodyParameters.length > 0 && formParameters.length > 0) {
-            throw new Error(`Choose either during @FormParam and @FileParam or body parameter  in '${this.getCurrentLocation()}' method.`);
-        }
-
-        return parameters;
-    }
-
-    private processMethodDecorators() {
-        const httpMethodDecorators = getNodeDecorators(this.node, decorator => this.supportsPathMethod(decorator.text));
-
-        if (!httpMethodDecorators || !httpMethodDecorators.length) { return; }
-        if (httpMethodDecorators.length > 1) {
-            throw new Error(`Only one HTTP Method decorator in '${this.getCurrentLocation}' method is acceptable, Found: ${httpMethodDecorators.map(d => d.text).join(', ')}`);
-        }
-
-        const methodDecorator = httpMethodDecorators[0];
-        this.method = methodDecorator.text.toLowerCase() as MethodType;
-
-        this.generatePath('METHOD_PATH');
-    }
-
-    private getMethodSuccessResponse(type: Resolver.BaseType): Response {
-        type = this.getMethodSuccessResponseType(type);
-
-        return {
-            description: Resolver.isVoidType(type) ? 'No content' : 'Ok',
-            examples: this.getMethodSuccessExamples(),
-            schema: type,
-            status: Resolver.isVoidType(type) ? '204' : '200',
-            name: Resolver.isVoidType(type) ? '204' : '200'
-        };
-    }
-
-    private getMethodSuccessResponseType(type: Resolver.BaseType) : Resolver.BaseType {
-        if(!Resolver.isVoidType(type)) {
-            return type;
-        }
-
-        const representation = this.current.decoratorMapper.match('RESPONSE_EXAMPLE', this.node);
-        if(typeof representation === 'undefined') {
-            return type;
-        }
-
-        const value = representation.getPropertyValue('TYPE');
-
-        if(
-            typeof value !== 'undefined' &&
-            hasOwnProperty(value, 'kind') &&
-            ts.isTypeNode(value as ts.Node)
-        ) {
-            type = new TypeNodeResolver(value as ts.TypeNode, this.current).resolve();
-        }
-
-        return type;
-    }
-
-    private getMethodSuccessExamples() {
-        const representation = this.current.decoratorMapper.match('RESPONSE_EXAMPLE', this.node);
-        if(typeof representation === 'undefined') {
-            return [];
-        }
-
-        let value : unknown = representation.getPropertyValue('PAYLOAD');
-        if(typeof value === 'undefined') {
-            return [];
-        }
-
-        return value;
-    }
-
-    private mergeResponses(responses: Response[], defaultResponse: Response) {
-        if (!responses || !responses.length) {
-            return [defaultResponse];
-        }
-
-        const index = responses.findIndex((resp) => resp.status === defaultResponse.status);
-
-        if (index >= 0) {
-            if (defaultResponse.examples && !responses[index].examples) {
-                responses[index].examples = defaultResponse.examples;
-            }
-        } else {
-            responses.push(defaultResponse);
-        }
-        return responses;
-    }
-
-    private supportsPathMethod(method: string) : boolean {
-        return (['ALL', 'GET', 'POST', 'PATCH', 'DELETE', 'PUT', 'OPTIONS', 'HEAD'] as MethodHttpVerbKey[]).some(m => m.toLowerCase() === method.toLowerCase());
-    }
-}