evaengine 1.0.14 → 2.0.0

package/dist/swagger/index.d.ts

@@ -0,0 +1,223 @@
+import { type GlobOptionsWithoutFileTypes } from 'fs';
+import * as doctrine from 'doctrine';
+import * as acorn from 'acorn';
+import Entitles from '../entities/index.js';
+import { StandardException, type ExceptionInput } from '../exceptions/index.js';
+export declare class AcornParsingException extends StandardException {
+}
+export declare class YamlParsingException extends StandardException {
+    annotation: Partial<Annotation>;
+    setAnnotation(annotation: Annotation): this;
+    getAnnotation(): Partial<Annotation>;
+    toString(): string;
+    constructor(exceptionOrMsg: ExceptionInput);
+}
+export declare const MODEL_TO_FRAGMENT_TYPES_MAPPING: Record<string, string>;
+export declare class Fragment {
+    getTypes(): string[];
+    isPath(): boolean;
+    isDefinition(): boolean;
+    isUnknown(): boolean;
+    isException(): boolean;
+    setParentFragment(fragment: Fragment): this;
+    getParentFragment(): Fragment | null;
+    correctSwaggerPath(swaggerDoc?: object): object;
+    toSwaggerDoc(exceptions?: Record<string, StandardException>): {
+        paths: {
+            [x: string]: {
+                [x: string]: object;
+            };
+        };
+        definitions?: undefined;
+    } | {
+        definitions: {
+            [x: string]: object;
+        };
+        paths?: undefined;
+    } | {
+        paths?: undefined;
+        definitions?: undefined;
+    } | {
+        definitions: {
+            [x: string]: {
+                properties: {
+                    code: {
+                        type: string;
+                        format: string;
+                    };
+                    message: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                example: {
+                    code: number;
+                    message: string;
+                };
+            };
+        };
+        paths: {
+            [x: string]: {
+                [x: string]: {
+                    responses: {
+                        [x: number]: {
+                            description: string;
+                            schema: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    static exceptionMapping(exception: StandardException): {
+        properties: {
+            code: {
+                type: string;
+                format: string;
+            };
+            message: {
+                type: string;
+            };
+        };
+        required: string[];
+        example: {
+            code: number;
+            message: string;
+        };
+    };
+    static factory(jsdoc: doctrine.AnnotationTag, annotation: Annotation): Fragment;
+    type: string;
+    description: string;
+    value: unknown;
+    file: string;
+    start: number;
+    end: number;
+    parent: Fragment | null;
+    constructor({ type, description, value, file, start, end }: {
+        type: string;
+        description: string;
+        value: unknown;
+        file: string;
+        start: number;
+        end: number;
+    });
+}
+export declare class Annotation {
+    getFragments(): Fragment[];
+    toString(): string;
+    getYamlErrors(): YamlParsingException[];
+    value: string;
+    file: string;
+    start: number;
+    end: number;
+    yamlErrors: YamlParsingException[];
+    fragments: Fragment[] | null;
+    constructor({ type, //Block
+    value, //Long string
+    file, //String
+    start, end }: {
+        type: string;
+        value: string;
+        file: string;
+        start: number;
+        end: number;
+    });
+}
+export declare class AnnotationsContainer {
+    getFile(): string;
+    hasAnnotations(): boolean;
+    getAnnotations(): Annotation[];
+    collectFragments(): Fragment[];
+    collectYamlErrors(): YamlParsingException[];
+    file: string;
+    annotations: Annotation[];
+    fragments: Fragment[];
+    constructor(file: string, acornComments: acorn.Comment[]);
+}
+type SwaggerLogger = {
+    debug: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+type ExceptionInterface = abstract new (...args: never[]) => object;
+type ModelAttributeLike = {
+    type: {
+        key: string;
+    };
+    comment?: string | null;
+    defaultValue?: unknown;
+    allowNull?: boolean;
+};
+type SwaggerModelProperty = {
+    type: string;
+    description?: string | null;
+    default?: unknown;
+};
+type SwaggerModelDefinition = {
+    type: string;
+    properties: Record<string, SwaggerModelProperty>;
+    required?: string[];
+};
+interface ExSwaggerOptions {
+    sourceRootPath: string;
+    compileDistPath: string;
+    models?: Entitles | null;
+    modelBlacklist?: string[];
+    swaggerDocsTemplate?: Record<string, unknown>;
+    logger?: SwaggerLogger | null;
+    swaggerUIPath?: string;
+    swaggerDocsPath?: string;
+    sourceFilesPath?: string | string[];
+    exceptionInterface?: ExceptionInterface;
+    extraSourcePaths?: string[];
+    exceptionPaths?: string[];
+}
+/**
+ * A Swagger Json document generator
+ * Generate document from
+ * - JS source code annotations (Parser is Doctrine)
+ * - ORM entities (Based on Sequelize)
+ * - EvaEngine Exceptions
+ */
+export declare class ExSwagger {
+    /**
+     * Get file path array by glob
+     */
+    static scanFiles(path: string, options?: GlobOptionsWithoutFileTypes): Promise<string[]>;
+    /**
+     * Get annotations from comments
+     * An annotation MUST start with double stars
+     */
+    static filesToAnnotationsContainers(files: string[]): Promise<AnnotationsContainer[]>;
+    static modelToSwaggerDefinition(model: Record<string, ModelAttributeLike>): SwaggerModelDefinition;
+    static modelsToSwaggerDefinitions(models: Record<string, unknown>, blacklist?: string[]): Map<string, SwaggerModelDefinition>;
+    static scanExceptions(path: string, exceptionInterface?: ExceptionInterface): Promise<Record<string, StandardException>>;
+    exportJson(dist?: string): Promise<Record<string, unknown>>;
+    static mergeAll(_template: Record<string, unknown>, fragments: Fragment[], exceptions: Record<string, StandardException>, modelDefinitions: Map<string, object>): Record<string, unknown>;
+    getStates(): {
+        swaggerTemplate: Record<string, unknown>;
+        modelBlacklist: string[];
+        sourceFilesPath: string[];
+        exceptionPaths: string[];
+        compileDistPath: string;
+        swaggerUIPath: string;
+        swaggerDocsPath: string;
+    };
+    getSwaggerUIPath(): string;
+    getSwaggerIndexHtml(): Promise<string>;
+    getCompileDistPath(): string;
+    logger: SwaggerLogger;
+    swaggerDocsTemplate: Record<string, unknown>;
+    models: Record<string, unknown> | null;
+    modelBlacklist: string[];
+    sourceFilesPath: string[];
+    exceptionPaths: string[];
+    exceptionInterface: ExceptionInterface;
+    compileDistPath: string;
+    swaggerUIPath: string;
+    swaggerDocsPath: string;
+    constructor({ sourceRootPath, compileDistPath, models, modelBlacklist, swaggerDocsTemplate, logger, swaggerUIPath, swaggerDocsPath, sourceFilesPath, exceptionInterface, extraSourcePaths, exceptionPaths }: ExSwaggerOptions);
+}
+export {};