@trapi/metadata 0.1.1 → 0.1.5

package/src/resolver/type.ts

@@ -1,257 +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 {Property} from "../type";
-
-export namespace Resolver {
-    export type TypeStringLiteral =
-        | 'string'
-        | 'boolean'
-        | 'double'
-        | 'float'
-        | 'file'
-        | 'integer'
-        | 'long'
-        | 'enum'
-        | 'array'
-        | 'datetime'
-        | 'date'
-        | 'binary'
-        | 'buffer'
-        | 'byte'
-        | 'void'
-        | 'object'
-        | 'any'
-        | 'refEnum'
-        | 'refObject'
-        | 'refAlias'
-        | 'nestedObjectLiteral'
-        | 'union'
-        | 'intersection';
-
-    export type RefTypeLiteral = 'refObject' | 'refEnum' | 'refAlias';
-
-    export type PrimitiveTypeLiteral = Exclude<TypeStringLiteral, RefTypeLiteral | 'enum' | 'array' | 'void' | 'nestedObjectLiteral' | 'union' | 'intersection'>;
-
-    export type Type =
-        | PrimitiveType
-        | ObjectsNoPropsType
-        | EnumType
-        | ArrayType
-        | FileType
-        | DateTimeType
-        | DateType
-        | BinaryType
-        | BufferType
-        | ByteType
-        | AnyType
-        | RefEnumType
-        | RefObjectType
-        | RefAliasType
-        | NestedObjectLiteralType
-        | UnionType
-        | IntersectionType;
-
-    // -------------------------------------------
-
-    export interface BaseType {
-        typeName: TypeStringLiteral;
-        typeArgument?: BaseType;
-    }
-
-    // -------------------------------------------
-    // Primitive Type(s)
-    // -------------------------------------------
-
-    export type PrimitiveType = StringType | BooleanType | DoubleType | FloatType | IntegerType | LongType | VoidType;
-
-    export interface AnyType extends  BaseType {
-        typeName: 'any';
-    }
-
-    export function isAnyType(param: BaseType) : param is AnyType {
-        return param.typeName === 'any';
-    }
-
-    export interface StringType extends BaseType {
-        typeName: 'string';
-    }
-
-    export interface BooleanType extends BaseType {
-        typeName: 'boolean';
-    }
-
-    export interface DoubleType extends BaseType {
-        typeName: 'double';
-    }
-
-    export interface FloatType extends BaseType {
-        typeName: 'float';
-    }
-
-    export interface IntegerType extends BaseType {
-        typeName: 'integer';
-    }
-
-    export interface LongType extends BaseType {
-        typeName: 'long';
-    }
-
-    export interface VoidType extends BaseType {
-        typeName: 'void';
-    }
-
-    export function isVoidType(param: BaseType) : param is VoidType {
-        return typeof param === 'undefined' || param.typeName === 'void';
-    }
-
-    // -------------------------------------------
-    // Simple Type(s)
-    // -------------------------------------------
-
-    export interface DateType extends BaseType {
-        typeName: 'date';
-    }
-
-    export interface FileType extends BaseType {
-        typeName: 'file';
-    }
-
-    export interface DateTimeType extends BaseType {
-        typeName: 'datetime';
-    }
-
-    export interface BinaryType extends BaseType {
-        typeName: 'binary';
-    }
-
-    export interface BufferType extends BaseType {
-        typeName: 'buffer';
-    }
-
-    export interface ByteType extends BaseType {
-        typeName: 'byte';
-    }
-
-    export interface AnyType extends BaseType {
-        typeName: 'any';
-    }
-
-    export interface ObjectsNoPropsType extends BaseType {
-        typeName: 'object';
-    }
-
-    // -------------------------------------------
-    // Complex Type(s)
-    // -------------------------------------------
-
-    export interface EnumType extends BaseType {
-        members: Array<string | number | boolean | null>;
-        typeName: 'enum';
-    }
-
-    export function isEnumType(param: BaseType) : param is EnumType {
-        return param.typeName === 'enum';
-    }
-
-    // -------------------------------------------
-
-    export interface ArrayType extends BaseType {
-        elementType: BaseType;
-        typeName: 'array';
-    }
-
-    export function isArrayType(param: BaseType) : param is ArrayType {
-        return param.typeName === 'array';
-    }
-
-    // -------------------------------------------
-
-    export interface NestedObjectLiteralType extends BaseType {
-        typeName: 'nestedObjectLiteral';
-        properties: Property[];
-        additionalProperties?: Type;
-    }
-
-    export function isNestedObjectLiteralType(param: BaseType) : param is NestedObjectLiteralType {
-        return param.typeName === 'nestedObjectLiteral';
-    }
-
-    // -------------------------------------------
-
-    export interface IntersectionType extends BaseType {
-        typeName: 'intersection';
-        members: Type[];
-    }
-
-    export function isIntersectionType(param: BaseType) : param is IntersectionType {
-        return param.typeName === 'intersection';
-    }
-
-    // -------------------------------------------
-
-    export interface UnionType extends BaseType {
-        typeName: 'union';
-        members: Type[];
-    }
-
-    export function isUnionType(param: BaseType) : param is UnionType {
-        return param.typeName === 'union';
-    }
-
-    // -------------------------------------------
-    // Reference Type(s)
-    // -------------------------------------------
-
-    export type ReferenceType = RefEnumType | RefObjectType | RefAliasType;
-
-    export interface ReferenceTypes {
-        [key: string]: ReferenceType;
-    }
-
-    export type DependencyResolver = (referenceTypes: Resolver.ReferenceTypes) => void;
-
-    export interface ReferenceTypeBase extends BaseType {
-        description?: string;
-        typeName: RefTypeLiteral;
-        refName: string;
-        example?: unknown;
-        deprecated: boolean;
-    }
-
-    export interface RefEnumType extends ReferenceTypeBase {
-        typeName: 'refEnum';
-        members: Array<string | number>;
-        memberNames?: string[];
-    }
-
-    export function isRefEnumType(param: BaseType) : param is RefEnumType {
-        return param.typeName === 'refEnum';
-    }
-
-    export interface RefObjectType extends ReferenceTypeBase {
-        typeName: 'refObject';
-        properties: Property[];
-        additionalProperties?: Type;
-    }
-
-    export function isRefObjectType(param: BaseType) : param is RefObjectType {
-        return param.typeName === 'refObject';
-    }
-
-    export interface RefAliasType extends Omit<Property, 'name' | 'required'>, ReferenceTypeBase {
-        typeName: 'refAlias';
-    }
-
-    export function isRefAliasType(param: BaseType) : param is RefAliasType {
-        return param.typeName === 'refAlias';
-    }
-
-    export function isReferenceType(param: BaseType) : param is ReferenceType {
-        return param.typeName === 'refEnum' || param.typeName === 'refAlias' || param.typeName === 'refObject';
-    }
-}

package/src/resolver/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 './initializer';
-export * from './validator';

package/src/resolver/utils/initializer.ts

@@ -1,81 +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 ts from 'typescript';
-import {Resolver} from "../type";
-import {hasOwnProperty} from "@trapi/metadata-utils";
-
-export function getInitializerValue(
-    initializer?: ts.Expression,
-    typeChecker?: ts.TypeChecker,
-    type?: Resolver.Type
-) : unknown {
-    if (!initializer) {
-        return undefined;
-    }
-
-    switch (initializer.kind) {
-        case ts.SyntaxKind.ArrayLiteralExpression:
-            const arrayLiteral = initializer as ts.ArrayLiteralExpression;
-            return arrayLiteral.elements.map(element => getInitializerValue(element, typeChecker));
-        case ts.SyntaxKind.StringLiteral:
-            return (initializer as ts.StringLiteral).text;
-        case ts.SyntaxKind.TrueKeyword:
-            return true;
-        case ts.SyntaxKind.FalseKeyword:
-            return false;
-        case ts.SyntaxKind.NumberKeyword:
-        case ts.SyntaxKind.FirstLiteralToken:
-            return Number((initializer as ts.NumericLiteral).text);
-        case ts.SyntaxKind.NewExpression:
-            const newExpression = initializer as ts.NewExpression;
-            const ident = newExpression.expression as ts.Identifier;
-
-            if (ident.text === 'Date') {
-                let date = new Date();
-                if (newExpression.arguments) {
-                    const newArguments = newExpression.arguments.filter(args => args.kind !== undefined);
-                    const argsValue = newArguments.map(args => getInitializerValue(args, typeChecker));
-                    if (argsValue.length > 0) {
-                        date = new Date(argsValue as any);
-                    }
-                }
-                const dateString = date.toISOString();
-                if (type && type.typeName === 'date') {
-                    return dateString.split('T')[0];
-                }
-
-                return dateString;
-            }
-            return;
-        case ts.SyntaxKind.ObjectLiteralExpression:
-            const objectLiteral = initializer as ts.ObjectLiteralExpression;
-            const nestedObject: any = {};
-            objectLiteral.properties.forEach((p: any) => {
-                nestedObject[p.name.text] = getInitializerValue(p.initializer, typeChecker);
-            });
-            return nestedObject;
-        default:
-            if(typeof initializer === 'undefined') {
-                return undefined;
-            } else {
-                if(typeof initializer.parent === 'undefined') {
-                    if(hasOwnProperty(initializer, 'text')) {
-                        return initializer.text;
-                    }
-
-                    return undefined;
-                }
-
-                const symbol = typeChecker.getSymbolAtLocation(initializer);
-                const extractedInitializer = symbol && symbol.valueDeclaration && hasInitializer(symbol.valueDeclaration) && (symbol.valueDeclaration.initializer as ts.Expression);
-                return extractedInitializer ? getInitializerValue(extractedInitializer, typeChecker) : undefined;
-            }
-    }
-}
-
-export const hasInitializer = (node: ts.Node): node is ts.HasInitializer => node.hasOwnProperty('initializer');

package/src/resolver/utils/validator.ts

@@ -1,144 +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 {ParameterDeclaration} from 'typescript';
-import {Validator} from "../../type";
-import {getJSDocTags} from "../../utils";
-
-export function getParameterValidators(parameter: ParameterDeclaration, name: string): Record<string, Validator> {
-    if (!parameter.parent) {
-        return {};
-    }
-
-    const getCommentValue = (comment?: string) => comment && comment.split(' ')[0];
-
-    const tags = getJSDocTags(parameter.parent, tag => {
-        let { comment } = tag;
-        const text : string = Array.isArray(comment) ? (comment.length > 0 ? comment[0].text : undefined) : comment;
-        return getSupportedParameterTags().some(value => !!comment && value === tag.tagName.text && getCommentValue(text) === name);
-    });
-
-    function getErrorMsg(comment?: string, isValue = true) : string {
-        if (!comment) {
-            return;
-        }
-        if (isValue) {
-            const indexOf = comment.indexOf(' ');
-            if (indexOf > 0) {
-                return comment.substr(indexOf + 1);
-            } else {
-                return undefined;
-            }
-        } else {
-            return comment;
-        }
-    }
-
-    const validators : Record<string, Validator> = {};
-
-    tags.map(tag => {
-        if (!tag.comment) {
-            return;
-        }
-
-        const name = tag.tagName.text;
-
-        let comment = typeof tag.comment === 'string' ? tag.comment : tag.comment[0].text ?? '';
-        comment = comment.substr(comment.indexOf(' ') + 1).trim();
-
-        const value = getCommentValue(comment);
-
-        switch (name) {
-            case 'uniqueItems':
-                validators[name] = {
-                    message: getErrorMsg(comment, false),
-                    value: undefined,
-                };
-                break;
-            case 'minimum':
-            case 'maximum':
-            case 'minItems':
-            case 'maxItems':
-            case 'minLength':
-            case 'maxLength':
-                if (isNaN(value as any)) {
-                    throw new Error(`${name} parameter use number.`);
-                }
-                validators[name] = {
-                    message: getErrorMsg(comment),
-                    value: Number(value),
-                };
-                break;
-            case 'minDate':
-            case 'maxDate':
-                if (typeof value !== 'string') {
-                    throw new Error(`${name} parameter use date format ISO 8601 ex. 2017-05-14, 2017-05-14T05:18Z`);
-                }
-                validators[name] = {
-                    message: getErrorMsg(comment),
-                    value,
-                };
-                break;
-            case 'pattern':
-                if (typeof value !== 'string') {
-                    throw new Error(`${name} parameter use string.`);
-                }
-
-                validators[name] = {
-                    message: getErrorMsg(comment),
-                    value: removeSurroundingQuotes(value),
-                };
-                break;
-            default:
-                if (name.startsWith('is')) {
-                    const errorMsg = getErrorMsg(comment, false);
-                    if (errorMsg) {
-                        validators[name] = {
-                            message: errorMsg,
-                            value: undefined,
-                        };
-                    }
-                }
-                break;
-        }
-    });
-
-    return validators;
-}
-
-function getSupportedParameterTags() {
-    return [
-        'isString',
-        'isBoolean',
-        'isInt',
-        'isLong',
-        'isFloat',
-        'isDouble',
-        'isDate',
-        'isDateTime',
-        'minItems',
-        'maxItems',
-        'uniqueItems',
-        'minLength',
-        'maxLength',
-        'pattern',
-        'minimum',
-        'maximum',
-        'minDate',
-        'maxDate',
-    ];
-}
-
-function removeSurroundingQuotes(str: string) {
-    if (str.startsWith('`') && str.endsWith('`')) {
-        return str.substring(1, str.length - 1);
-    }
-    if (str.startsWith('```') && str.endsWith('```')) {
-        return str.substring(3, str.length - 3);
-    }
-    return str;
-}

package/src/type.ts

@@ -1,185 +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 {Resolver} from "./resolver";
-import {Decorator} from "./decorator";
-import {Cache} from "./cache";
-
-export interface Config {
-    /**
-     * The entry point to your API.
-     */
-    entryFile: string | string[];
-    /**
-     * Directory to ignore during TypeScript files scan.
-     * Default: []
-     */
-    ignore?: string[];
-    /**
-     * Directory to store and cache metadata cache files.
-     * Default: false
-     */
-    cache?: string | boolean | Partial<Cache.Config>;
-    /**
-     * Decorator config.
-     * Default: {
-     *      library: ['decorators-express', 'typescript-rest'],
-     *      internal: true
-     * }
-     */
-    decorator?: Decorator.Config;
-}
-
-/**
- * The output specification for metadata generation.
- */
-export interface GeneratorOutput {
-    /**
-     * A Controller is a collection of grouped methods (GET, POST, ...)
-     * for a common URL path (i.e /users) or an more explicit URL path (i.e. /users/:id).
-     */
-    controllers: Controller[];
-    /**
-     * ReferenceTypes is an object of found types (interfaces, type, ...),
-     * and classes which were detected during code analysis.
-     */
-    referenceTypes: Resolver.ReferenceTypes;
-}
-
-export interface Controller {
-    /**
-     * File Location of the Controller.
-     */
-    location: string;
-    /**
-     * Array of found method ( class functions )
-     * for a specific controller (class)
-     */
-    methods: Method[];
-    name: string;
-    /**
-     * The relative URL Path, i.e /users
-     */
-    path: string;
-    /**
-     * Allowed Content-Types to pass
-     * data according the definition.
-     *
-     * i.e. ['application/json']
-     */
-    consumes: string[];
-    /**
-     * Possible Content-Types to receive
-     * data according the definition.
-     *
-     * i.e. ['application/json']
-     */
-    produces: string[];
-    responses: Response[];
-    /**
-     * Tags can be used to group controllers
-     * by a name together.
-     *
-     * i.e. ['auth']
-     */
-    tags: string[];
-    security?: Security[];
-}
-
-export interface Security {
-    name: string;
-    scopes?: string[];
-}
-
-export interface Method {
-    operationId?: string;
-    deprecated?: boolean;
-    description: string;
-    method: MethodType;
-    extensions: Extension[];
-    name: string;
-    parameters: Parameter[];
-    path: string;
-    type: Resolver.BaseType;
-    tags: string[];
-    responses: Response[];
-    security?: Security[];
-    summary?: string;
-    consumes: string[];
-    produces: string[];
-    hidden: boolean;
-}
-
-export type MethodType = 'get' | 'post' | 'put' | 'delete' | 'options' | 'head' | 'patch';
-
-export interface Extension {
-    key: string;
-    value: ExtensionType | ExtensionType[];
-}
-
-export type ExtensionType =
-    string
-    | number
-    | boolean
-    | null
-    | ExtensionType[]
-    | { [name: string]: ExtensionType | ExtensionType[] };
-
-export interface Parameter {
-    parameterName: string;
-    description: string;
-    in: string;
-    name: string;
-    required: boolean;
-    type: Resolver.BaseType;
-    collectionFormat?: 'csv' | 'multi' | 'pipes' | 'ssv' | 'tsv';
-    allowEmptyValue?: boolean;
-    default?: any;
-    maxItems?: number;
-    minItems?: number;
-    deprecated?: boolean;
-
-    example?: unknown[];
-    validators?: Record<string, Validator>;
-}
-
-export interface ArrayParameter extends Parameter {
-    type: Resolver.ArrayType;
-}
-
-export interface Validator {
-    value?: unknown,
-    message?: string
-}
-
-export interface Property {
-    default?: any;
-    format?: string;
-    example?: unknown;
-    validators?: Record<string, { value?: any, message?: string }>;
-    description?: string;
-    name: string;
-    type: Resolver.Type;
-    required: boolean;
-    deprecated: boolean;
-}
-
-export interface Response {
-    description: string;
-    examples?: unknown[] | unknown;
-    headers?: Resolver.NestedObjectLiteralType | Resolver.RefObjectType;
-    name: string;
-    status: string;
-    schema?: Resolver.BaseType;
-
-}
-
-
-
-
-
-