@dooboostore/simple-boot-http-server 1.0.19 → 1.0.21

package/src/filters/OpenApi3Filter.ts

@@ -0,0 +1,158 @@
+import {Filter} from './Filter';
+import {HttpStatus} from '../codes/HttpStatus';
+import {SimpleBootHttpServer} from '../SimpleBootHttpServer';
+import {RequestResponse} from '../models/RequestResponse';
+import {getUrlMappings} from '../decorators/MethodMapping';
+
+type MethodType = {
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    parameters?: {
+        name: string;
+        in: string;
+        required: boolean;
+        schema: {
+            type: string;
+            format?: string;
+            items?: {
+                type: string;
+                format?: string;
+            }
+        }
+    }[];
+    responses: {
+        [code: string]: {
+            description: string;
+            content?: {
+                [type: string]: {
+                    schema: {
+                        type: string;
+                        format?: string;
+                        items?: {
+                            type: string;
+                            format?: string;
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+type PathType = {
+    [method: string]: MethodType
+};
+type PathsType = {
+    [path: string]: PathType
+};
+export type OpenApiType = {
+    openapi: string;
+    info?: {
+        title?: string;
+        description?: string;
+        contact?: {
+            name?: string;
+            email?: string;
+        }
+    }
+    servers?: { url: string }[],
+    paths?: PathsType
+    components?: {
+        schemas?: {
+            [key: string]: {
+                type: string;
+                required?: string[];
+                properties?: {
+                    [key: string]: {
+                        type: string;
+                        format?: string;
+                        items?: {
+                            type: string;
+                            format?: string;
+                        }
+                    }
+                }
+            }
+        }
+        securitySchemes?: {
+            [key: string]: {
+                type: string;
+                description?: string;
+                in?: string;
+                name?: string;
+                scheme?: string;
+                bearerFormat?: string;
+                flows?: {
+                    [key: string]: {
+                        authorizationUrl?: string;
+                        tokenUrl?: string;
+                        refreshUrl?: string;
+                        scopes?: {
+                            [key: string]: {
+                                description?: string;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+export type OpenApi3FilterConfig = {
+    info?: {
+        title?: string;
+        description?: string;
+        contact?: {
+            name?: string;
+            email?: string;
+        }
+    }
+    servers?: { url: string }[],
+}
+const DefulatData: OpenApiType = {
+    openapi: '3.0.1',
+    info: {
+        title: 'SimpleBootHttpServer OpenApi3',
+        description: 'SimpleBootHttpServer OpenApi3',
+    }
+}
+
+export class OpenApi3Filter implements Filter {
+    private openApiConfig: any;
+
+    constructor(public config: { path: string, excludePath?: { method: string, path: string }[] }, openApiConfig?: OpenApi3FilterConfig) {
+        this.openApiConfig = Object.assign(Object.assign({}, DefulatData), openApiConfig ?? {})
+    }
+    async onInit(app: SimpleBootHttpServer){
+    }
+    async proceedBefore({rr, app}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+        if (rr.reqUrl === this.config.path) {
+            const map = app.routerManager.routingMap();
+            // let routers = app.simstanceManager.getSimAtomics().filter((it: SimAtomic) => it.getConfig(RouterMetadataKey));
+            const data = {
+                paths: {} as PathsType
+            } as OpenApiType;
+
+            Object.entries(map).filter(([k, v]) => typeof v !== 'string').forEach(([k, v]) => {
+                const method = data.paths![k] = {} as PathType;
+                getUrlMappings(v)?.forEach(it => {
+                    method[it.config.method] = {
+                        summary: it.propertyKey,
+                        description: it.propertyKey
+                        // operationId: it.operationId,
+                        // parameters: it.parameters,
+                        // responses: it.responses,
+                    } as MethodType
+                });
+            })
+
+            rr.resWriteJson(Object.assign(Object.assign({}, this.openApiConfig), data)).resStatusCode(HttpStatus.Ok).resEnd();
+            return false;
+        }
+        return true;
+    }
+
+    async proceedAfter({rr, app}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+        return true;
+    }
+}

package/src/filters/ResourceFilter.ts

@@ -0,0 +1,72 @@
+import { Filter } from '../filters/Filter';
+import fs from 'fs';
+import path from 'path';
+import mime from 'mime-types';
+import { HttpHeaders } from '../codes/HttpHeaders';
+import { HttpStatus } from '../codes/HttpStatus';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import { RequestResponse } from '../models/RequestResponse';
+
+export type RequestFilterType = string | RegExp | ((rr: RequestResponse, app: SimpleBootHttpServer) => boolean) | ((rr: RequestResponse, app: SimpleBootHttpServer) => Promise<boolean>);
+
+export class ResourceFilter implements Filter {
+    constructor(private resourceDistPath: string, private resourceRegex: (RequestFilterType | { request: RequestFilterType, dist: string })[] = []) {
+    }
+
+    async onInit(app: SimpleBootHttpServer) {
+    }
+
+    async proceedBefore({rr, app}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+        const url = (rr.reqUrlPathName ?? '').replace(/\.\./g, '');
+        const urlObj = rr.reqUrlObject;
+        // const requestUrl = parse(rr.reqUrl ?? '', true);
+        let sw = true;
+        const regExps = this.resourceRegex.filter(it => {
+            if (it instanceof RegExp) {
+                return it.test(url);
+            }
+
+            if (typeof it === 'string') {
+                return RegExp(it).test(url);
+            }
+
+            if (typeof it === 'function') {
+                return it(rr, app);
+            }
+
+            if (typeof it === 'object' && 'request' in it) {
+                if (typeof it.request === 'function') {
+                    return it.request(rr, app);
+                }
+                return RegExp(it.request).test(url);
+            }
+        })
+        // console.log('regExps', regExps, url, this.resourceRegex);
+        // eslint-disable-next-line no-unused-vars
+        for (const it of regExps) {
+            const resourcePath = path.join(this.resourceDistPath, typeof it === 'object' && 'dist' in it ? it.dist : urlObj.pathname);
+            // console.log('ResourceFilter', resourcePath, it, urlObj.pathname, url);
+            sw = false;
+            // console.log('-----', resourcePath);
+            if (fs.existsSync(resourcePath)) {
+                // const header = {} as any;
+                // header[HttpHeaders.ContentType] = mime.lookup(resourcePath);
+                // res.writeHead(HttpStatus.Ok, header);
+                rr.resStatusCode(HttpStatus.Ok);
+                rr.resSetHeader(HttpHeaders.ContentType, mime.lookup(resourcePath).toString());
+                await rr.resEnd(fs.readFileSync(resourcePath));
+                break;
+            } else {
+                rr.resStatusCode(HttpStatus.NotFound)
+                await rr.resEnd();
+                break;
+            }
+            sw = false;
+        }
+        return sw;
+    }
+
+    async proceedAfter({rr, app}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+        return true;
+    }
+}

package/src/filters/ThrowFilter.ts

@@ -0,0 +1,23 @@
+import { Filter } from '../filters/Filter';
+import { RequestResponse } from '../models/RequestResponse';
+import {SimpleBootHttpServer} from '../SimpleBootHttpServer';
+
+export class ThrowFilter implements Filter {
+    constructor(private error: any) {
+    }
+
+    async onInit(app: SimpleBootHttpServer){
+    }
+
+    async proceedBefore({rr, app}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+        return true;
+    }
+
+    async proceedAfter({rr, app}: {rr: RequestResponse, app: SimpleBootHttpServer, carrier: Map<string, any>}) {
+        const sw = rr.resIsDone();
+        if (!sw) {
+            throw this.error;
+        };
+        return false;
+    }
+}

package/{dist/esm/filters/index.d.ts → src/filters/index.ts}

@@ -4,4 +4,3 @@ export * from './HttpStatusFilter';
 export * from './OpenApi3Filter';
 export * from './ResourceFilter';
 export * from './ThrowFilter';
-//# sourceMappingURL=index.d.ts.map

package/src/index.ts

@@ -0,0 +1,13 @@
+// export * from './codes';
+// export * from './decorators';
+// export * from './endpoints';
+// export * from './errors';
+// export * from './filters';
+// export * from './inject';
+// export * from './lifecycle';
+// export * from './models';
+// export * from './option';
+// export * from './resolvers';
+// export * from './session';
+// export * from './SimpleBootHttpServer';
+export default {}

package/src/inject/InjectSituationType.ts

@@ -0,0 +1,3 @@
+export namespace InjectSituationType {
+  export const TransactionManager = Symbol('TransactionManager');
+}

package/{dist/esm/inject/index.d.ts → src/inject/index.ts}

@@ -1,2 +1 @@
 export * from './InjectSituationType';
-//# sourceMappingURL=index.d.ts.map

package/src/lifecycle/OnInit.ts

@@ -0,0 +1,5 @@
+import {SimpleBootHttpServer} from '../SimpleBootHttpServer';
+
+export interface OnInit {
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+}

package/src/lifecycle/index.ts

@@ -0,0 +1 @@
+export * from './OnInit';