@dooboostore/simple-boot-http-server 1.0.14

package/errors/NotFoundError.js

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+import { HttpStatus } from '../codes/HttpStatus';
+export class NotFoundError extends HttpError {
+    constructor({ status = HttpStatus.NotFound, message = 'Not Found' } = {}) {
+        super({ status, message });
+    }
+}
+//# sourceMappingURL=NotFoundError.js.map

package/errors/UnauthorizedError.d.ts

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+export declare class UnauthorizedError extends HttpError {
+    constructor({ status, message }?: {
+        status?: number;
+        message?: string;
+    });
+}
+//# sourceMappingURL=UnauthorizedError.d.ts.map

package/errors/UnauthorizedError.js

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+import { HttpStatus } from '../codes/HttpStatus';
+export class UnauthorizedError extends HttpError {
+    constructor({ status = HttpStatus.Unauthorized, message = 'Unauthorized' } = {}) {
+        super({ status, message });
+    }
+}
+//# sourceMappingURL=UnauthorizedError.js.map

package/filters/CacheFilter.d.ts

@@ -0,0 +1,45 @@
+import { Filter } from '../filters/Filter';
+import { RequestResponse } from '../models/RequestResponse';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+export type CacheFilterSessionType = {
+    key: string;
+    lifeTime: number;
+    isUpdate: boolean;
+    responseHeaders?: string[];
+};
+type KeyAndConfig = {
+    key: string;
+    lifeTime?: number;
+    responseHeaders?: string[];
+};
+export declare class CacheFilter implements Filter {
+    private config;
+    static readonly CARRIER_KEY_NAME = "_CARRIER_CACHE_FILTER_KEY_NAME";
+    private storage;
+    private cacheConfig;
+    constructor(config: {
+        config: {
+            cacheDir?: string;
+            lifeTime: number;
+            startUpClean?: boolean;
+        };
+        filter?: (rr: RequestResponse, app: SimpleBootHttpServer) => boolean;
+        key: (rr: RequestResponse, app: SimpleBootHttpServer) => KeyAndConfig;
+    });
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+    proceedBefore({ rr, app, carrier }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    private deleteChunk;
+    private getChunk;
+    proceedAfter({ rr, app, carrier }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    private writeChunk;
+}
+export {};
+//# sourceMappingURL=CacheFilter.d.ts.map

package/filters/CacheFilter.js

@@ -0,0 +1,145 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { FileUtils } from '@dooboostore/core-node/file/FileUtils';
+import { ConvertUtils } from '@dooboostore/core-node/convert/ConvertUtils';
+import { RandomUtils } from '@dooboostore/core/random/RandomUtils';
+export class CacheFilter {
+    constructor(config) {
+        this.config = config;
+        this.storage = new Map();
+        if (config.config.cacheDir && config.config.startUpClean) {
+            FileUtils.deleteSync(config.config.cacheDir, { options: { recursive: true } });
+        }
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    proceedBefore({ rr, app, carrier }) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var _h, _j, _k;
+        return __awaiter(this, void 0, void 0, function* () {
+            const filter = (_b = (_a = this.config).filter) === null || _b === void 0 ? void 0 : _b.call(_a, rr, app);
+            if (!filter) {
+                return true;
+            }
+            if (this.config.config.cacheDir) {
+                FileUtils.mkdirSync(this.config.config.cacheDir, { recursive: true });
+            }
+            if (!this.cacheConfig && this.config.config.cacheDir) {
+                try {
+                    this.cacheConfig = JSON.parse(ConvertUtils.toString(FileUtils.readSync([this.config.config.cacheDir, 'cacheConfig.json'], { option: { encoding: 'utf-8' } })));
+                }
+                catch (e) {
+                }
+            }
+            const date = new Date().toISOString();
+            (_c = this.cacheConfig) !== null && _c !== void 0 ? _c : (this.cacheConfig = {
+                createDate: date,
+                updateDate: date,
+                caches: {}
+            });
+            (_d = (_h = this.cacheConfig).createDate) !== null && _d !== void 0 ? _d : (_h.createDate = date);
+            (_e = (_j = this.cacheConfig).updateDate) !== null && _e !== void 0 ? _e : (_j.updateDate = date);
+            (_f = (_k = this.cacheConfig).caches) !== null && _f !== void 0 ? _f : (_k.caches = {});
+            const rkey = this.config.key(rr, app);
+            const sessionData = { key: rkey.key, lifeTime: (_g = rkey.lifeTime) !== null && _g !== void 0 ? _g : this.config.config.lifeTime, isUpdate: false, responseHeaders: rkey.responseHeaders };
+            const cache = this.cacheConfig.caches[sessionData.key];
+            if (cache) {
+                const existes = this.config.config.cacheDir ? FileUtils.existesSync(cache.path) : this.storage.has(cache.path);
+                const diffTime = Date.now() - cache.createTime;
+                if (!existes || diffTime > cache.lifeTime) {
+                    delete this.cacheConfig[sessionData.key];
+                    this.deleteChunk(cache.path);
+                    sessionData.isUpdate = true;
+                }
+                else {
+                    rr.resSetHeaders(Object.assign(Object.assign({}, cache.responseHeader), { cacheFilter: `true;remainTime=${cache.lifeTime - diffTime}` }));
+                    try {
+                        const chunk = this.getChunk(cache.path);
+                        yield rr.resEnd(chunk);
+                    }
+                    catch (e) {
+                        console.log('--------e', e);
+                    }
+                }
+            }
+            else {
+                sessionData.isUpdate = true;
+            }
+            carrier.set(CacheFilter.CARRIER_KEY_NAME, sessionData);
+            return sessionData.isUpdate;
+        });
+    }
+    deleteChunk(path) {
+        if (this.config.config.cacheDir && FileUtils.existesSync(path)) {
+            FileUtils.deleteFileSync(path);
+        }
+        else if (this.storage.has(path)) {
+            this.storage.delete(path);
+        }
+    }
+    getChunk(path) {
+        return this.config.config.cacheDir ? FileUtils.readSync(path) : this.storage.get(path);
+    }
+    proceedAfter({ rr, app, carrier }) {
+        var _a, _b;
+        var _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessionData = carrier.get(CacheFilter.CARRIER_KEY_NAME);
+            if (sessionData && sessionData.isUpdate) {
+                try {
+                    if (this.config.config.cacheDir) {
+                        FileUtils.mkdirSync([this.config.config.cacheDir, 'caches'], { recursive: true });
+                    }
+                    const resBody = rr.resBodyData();
+                    if (!resBody) {
+                        return true;
+                    }
+                    let p = undefined;
+                    const destFileUUID = RandomUtils.uuid4();
+                    p = this.writeChunk(destFileUUID, resBody);
+                    const updateDateNow = Date.now();
+                    const updateDate = new Date(updateDateNow).toISOString();
+                    (_a = (_c = this.cacheConfig).createDate) !== null && _a !== void 0 ? _a : (_c.createDate = updateDate);
+                    this.cacheConfig.updateDate = updateDate;
+                    const responseHeaders = {};
+                    (_b = sessionData.responseHeaders) === null || _b === void 0 ? void 0 : _b.map(it => it.toLowerCase()).forEach(it => {
+                        responseHeaders[it] = rr.resHeader(it);
+                    });
+                    this.cacheConfig.caches[sessionData.key] = {
+                        path: p,
+                        createTime: updateDateNow,
+                        lifeTime: sessionData.lifeTime,
+                        responseHeader: responseHeaders
+                    };
+                    if (this.config.config.cacheDir) {
+                        FileUtils.write(JSON.stringify(this.cacheConfig), { path: [this.config.config.cacheDir, 'cacheConfig.json'] });
+                    }
+                }
+                catch (e) {
+                    console.log('---', e);
+                }
+            }
+            return true;
+        });
+    }
+    writeChunk(destFileUUID, resBody) {
+        if (this.config.config.cacheDir) {
+            return FileUtils.write(resBody, { path: [this.config.config.cacheDir, 'caches', destFileUUID] });
+        }
+        else {
+            this.storage.set(destFileUUID, resBody);
+            return destFileUUID;
+        }
+    }
+}
+CacheFilter.CARRIER_KEY_NAME = '_CARRIER_CACHE_FILTER_KEY_NAME';
+//# sourceMappingURL=CacheFilter.js.map

package/filters/Filter.d.ts

@@ -0,0 +1,17 @@
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import { RequestResponse } from '../models/RequestResponse';
+import { OnInit } from '../lifecycle/OnInit';
+export interface Filter extends OnInit {
+    proceedBefore(data: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    proceedAfter(data: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        before: boolean;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+}
+//# sourceMappingURL=Filter.d.ts.map

package/filters/Filter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Filter.js.map

package/filters/HttpStatusFilter.d.ts

@@ -0,0 +1,20 @@
+import { Filter } from '../filters/Filter';
+import { HttpStatus } from '../codes/HttpStatus';
+import { RequestResponse } from '../models/RequestResponse';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+export declare class HttpStatusFilter implements Filter {
+    private httpStatus;
+    constructor(httpStatus: HttpStatus | number);
+    proceedBefore({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    proceedAfter({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+}
+//# sourceMappingURL=HttpStatusFilter.d.ts.map

package/filters/HttpStatusFilter.js

@@ -0,0 +1,31 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class HttpStatusFilter {
+    constructor(httpStatus) {
+        this.httpStatus = httpStatus;
+    }
+    proceedBefore({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            rr.resStatusCode(this.httpStatus);
+            rr.resEnd();
+            return false;
+        });
+    }
+    proceedAfter({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+}
+//# sourceMappingURL=HttpStatusFilter.js.map

package/filters/OpenApi3Filter.d.ts

@@ -0,0 +1,142 @@
+import { Filter } from './Filter';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import { RequestResponse } from '../models/RequestResponse';
+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;
+    }[];
+};
+export declare class OpenApi3Filter implements Filter {
+    config: {
+        path: string;
+        excludePath?: {
+            method: string;
+            path: string;
+        }[];
+    };
+    private openApiConfig;
+    constructor(config: {
+        path: string;
+        excludePath?: {
+            method: string;
+            path: string;
+        }[];
+    }, openApiConfig?: OpenApi3FilterConfig);
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+    proceedBefore({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    proceedAfter({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=OpenApi3Filter.d.ts.map

package/filters/OpenApi3Filter.js

@@ -0,0 +1,57 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { HttpStatus } from '../codes/HttpStatus';
+import { getUrlMappings } from '../decorators/MethodMapping';
+const DefulatData = {
+    openapi: '3.0.1',
+    info: {
+        title: 'SimpleBootHttpServer OpenApi3',
+        description: 'SimpleBootHttpServer OpenApi3',
+    }
+};
+export class OpenApi3Filter {
+    constructor(config, openApiConfig) {
+        this.config = config;
+        this.openApiConfig = Object.assign(Object.assign({}, DefulatData), openApiConfig !== null && openApiConfig !== void 0 ? openApiConfig : {});
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    proceedBefore({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (rr.reqUrl === this.config.path) {
+                const map = app.routerManager.routingMap();
+                const data = {
+                    paths: {}
+                };
+                Object.entries(map).filter(([k, v]) => typeof v !== 'string').forEach(([k, v]) => {
+                    var _a;
+                    const method = data.paths[k] = {};
+                    (_a = getUrlMappings(v)) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+                        method[it.config.method] = {
+                            summary: it.propertyKey,
+                            description: it.propertyKey
+                        };
+                    });
+                });
+                rr.resWriteJson(Object.assign(Object.assign({}, this.openApiConfig), data)).resStatusCode(HttpStatus.Ok).resEnd();
+                return false;
+            }
+            return true;
+        });
+    }
+    proceedAfter({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+//# sourceMappingURL=OpenApi3Filter.js.map

package/filters/ResourceFilter.d.ts

@@ -0,0 +1,24 @@
+import { Filter } from '../filters/Filter';
+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 declare class ResourceFilter implements Filter {
+    private resourceDistPath;
+    private resourceRegex;
+    constructor(resourceDistPath: string, resourceRegex?: (RequestFilterType | {
+        request: RequestFilterType;
+        dist: string;
+    })[]);
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+    proceedBefore({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    proceedAfter({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+}
+//# sourceMappingURL=ResourceFilter.d.ts.map

package/filters/ResourceFilter.js

@@ -0,0 +1,72 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs';
+import path from 'path';
+import mime from 'mime-types';
+import { HttpHeaders } from '../codes/HttpHeaders';
+import { HttpStatus } from '../codes/HttpStatus';
+export class ResourceFilter {
+    constructor(resourceDistPath, resourceRegex = []) {
+        this.resourceDistPath = resourceDistPath;
+        this.resourceRegex = resourceRegex;
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    proceedBefore({ rr, app }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = ((_a = rr.reqUrlPathName) !== null && _a !== void 0 ? _a : '').replace(/\.\./g, '');
+            const urlObj = rr.reqUrlObject;
+            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);
+                }
+            });
+            for (const it of regExps) {
+                const resourcePath = path.join(this.resourceDistPath, typeof it === 'object' && 'dist' in it ? it.dist : urlObj.pathname);
+                sw = false;
+                if (fs.existsSync(resourcePath)) {
+                    rr.resStatusCode(HttpStatus.Ok);
+                    rr.resSetHeader(HttpHeaders.ContentType, mime.lookup(resourcePath).toString());
+                    yield rr.resEnd(fs.readFileSync(resourcePath));
+                    break;
+                }
+                else {
+                    rr.resStatusCode(HttpStatus.NotFound);
+                    yield rr.resEnd();
+                    break;
+                }
+                sw = false;
+            }
+            return sw;
+        });
+    }
+    proceedAfter({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+//# sourceMappingURL=ResourceFilter.js.map

package/filters/ThrowFilter.d.ts

@@ -0,0 +1,19 @@
+import { Filter } from '../filters/Filter';
+import { RequestResponse } from '../models/RequestResponse';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+export declare class ThrowFilter implements Filter {
+    private error;
+    constructor(error: any);
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+    proceedBefore({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    proceedAfter({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+}
+//# sourceMappingURL=ThrowFilter.d.ts.map

package/filters/ThrowFilter.js

@@ -0,0 +1,34 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class ThrowFilter {
+    constructor(error) {
+        this.error = error;
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    proceedBefore({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+    proceedAfter({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sw = rr.resIsDone();
+            if (!sw) {
+                throw this.error;
+            }
+            ;
+            return false;
+        });
+    }
+}
+//# sourceMappingURL=ThrowFilter.js.map

package/inject/InjectSituationType.d.ts

@@ -0,0 +1,4 @@
+export declare namespace InjectSituationType {
+    const TransactionManager: unique symbol;
+}
+//# sourceMappingURL=InjectSituationType.d.ts.map

package/inject/InjectSituationType.js

@@ -0,0 +1,5 @@
+export var InjectSituationType;
+(function (InjectSituationType) {
+    InjectSituationType.TransactionManager = Symbol('TransactionManager');
+})(InjectSituationType || (InjectSituationType = {}));
+//# sourceMappingURL=InjectSituationType.js.map

package/lifecycle/OnInit.d.ts

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

package/lifecycle/OnInit.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=OnInit.js.map