@dooboostore/simple-boot-http-server 1.0.14

package/models/datas/Resource.d.ts

@@ -0,0 +1,11 @@
+import { RequestResponse } from '../RequestResponse';
+export declare class Resource {
+    path: string | RequestResponse | URL;
+    rootPath: string;
+    constructor(path: string | RequestResponse | URL, rootPath?: string);
+    get absolutePath(): string;
+    get conTentType(): string;
+    get data(): Promise<string>;
+    write(rr: RequestResponse): Promise<void>;
+}
+//# sourceMappingURL=Resource.d.ts.map

package/models/datas/Resource.js

@@ -0,0 +1,55 @@
+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 { RequestResponse } from '../RequestResponse';
+import { HttpStatus } from '../../codes/HttpStatus';
+import { HttpHeaders } from '../../codes/HttpHeaders';
+export class Resource {
+    constructor(path, rootPath = process.cwd()) {
+        this.path = path;
+        this.rootPath = rootPath;
+    }
+    get absolutePath() {
+        if (this.path instanceof RequestResponse) {
+            return path.join(this.rootPath, this.path.reqUrlObj().pathname);
+        }
+        else if (this.path instanceof URL) {
+            return path.join(this.rootPath, this.path.pathname);
+        }
+        else {
+            return path.join(this.rootPath, this.path);
+        }
+    }
+    get conTentType() {
+        return mime.lookup(this.absolutePath).toString();
+    }
+    get data() {
+        const promise = new Promise((resolve, reject) => {
+            fs.readFile('', (error, fileBuffer) => {
+                if (error) {
+                    reject(error);
+                }
+                const fileContent = fileBuffer.toString();
+                resolve(fileContent);
+            });
+        });
+        return promise;
+    }
+    write(rr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            rr.resStatusCode(HttpStatus.Ok);
+            rr.resSetHeader(HttpHeaders.ContentType, this.conTentType);
+            yield rr.resEnd(fs.readFileSync(this.absolutePath));
+        });
+    }
+}
+//# sourceMappingURL=Resource.js.map

package/models/datas/body/ReqFormUrlBody.d.ts

@@ -0,0 +1,4 @@
+export declare class ReqFormUrlBody {
+    [key: string]: string | string[];
+}
+//# sourceMappingURL=ReqFormUrlBody.d.ts.map

package/models/datas/body/ReqFormUrlBody.js

@@ -0,0 +1,3 @@
+export class ReqFormUrlBody {
+}
+//# sourceMappingURL=ReqFormUrlBody.js.map

package/models/datas/body/ReqJsonBody.d.ts

@@ -0,0 +1,4 @@
+export declare class ReqJsonBody {
+    [key: string]: any;
+}
+//# sourceMappingURL=ReqJsonBody.d.ts.map

package/models/datas/body/ReqJsonBody.js

@@ -0,0 +1,3 @@
+export class ReqJsonBody {
+}
+//# sourceMappingURL=ReqJsonBody.js.map

package/models/datas/body/ReqMultipartFormBody.d.ts

@@ -0,0 +1,6 @@
+import { MultipartData } from '../MultipartData';
+export declare class ReqMultipartFormBody {
+    field: MultipartData[];
+    constructor(field?: MultipartData[]);
+}
+//# sourceMappingURL=ReqMultipartFormBody.d.ts.map

package/models/datas/body/ReqMultipartFormBody.js

@@ -0,0 +1,6 @@
+export class ReqMultipartFormBody {
+    constructor(field = []) {
+        this.field = field;
+    }
+}
+//# sourceMappingURL=ReqMultipartFormBody.js.map

package/models/method/patch/PatchJson.d.ts

@@ -0,0 +1,8 @@
+import { Operation as JsonOperation } from 'fast-json-patch';
+export type Operation = JsonOperation;
+export declare class PatchJson {
+    private patch;
+    constructor(patch: Operation[]);
+    apply(obj: any): any;
+}
+//# sourceMappingURL=PatchJson.d.ts.map

package/models/method/patch/PatchJson.js

@@ -0,0 +1,11 @@
+import jsonpatch from 'fast-json-patch';
+export class PatchJson {
+    constructor(patch) {
+        this.patch = patch;
+    }
+    apply(obj) {
+        obj = jsonpatch.applyPatch(obj, this.patch).newDocument;
+        return obj;
+    }
+}
+//# sourceMappingURL=PatchJson.js.map

package/option/HttpServerOption.d.ts

@@ -0,0 +1,85 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { InitOptionType, SimOption } from '@dooboostore/simple-boot/SimOption';
+import { ConstructorType } from '@dooboostore/core/types';
+import { Server as HttpServer, ServerOptions } from 'http';
+import { Server as HttpsServer, ServerOptions as HttpsServerOption } from 'https';
+import { Filter } from '../filters/Filter';
+import { EndPoint } from '../endpoints/EndPoint';
+import { RequestResponse } from '../models/RequestResponse';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import { TransactionManager } from '@dooboostore/core/transaction/TransactionManager';
+export type Listen = {
+    port?: number;
+    hostname?: string;
+    backlog?: number;
+    listeningListener?: (server: SimpleBootHttpServer, httpServer: HttpServer | HttpsServer) => void;
+};
+export interface ListenData extends Listen {
+    port: number;
+    hostname: string;
+}
+export declare class HttpServerOption extends SimOption {
+    static readonly DEFAULT_PORT = 8081;
+    static readonly DEFAULT_HOSTNAME = "127.0.0.1";
+    serverOption?: ServerOptions | HttpsServerOption;
+    listen: ListenData;
+    filters?: (Filter | ConstructorType<Filter>)[];
+    fileUploadTempPath?: string;
+    requestEndPoints?: (EndPoint | ConstructorType<EndPoint>)[];
+    closeEndPoints?: (EndPoint | ConstructorType<EndPoint>)[];
+    errorEndPoints?: (EndPoint | ConstructorType<EndPoint>)[];
+    sessionOption: {
+        key: string;
+        expiredTime: number;
+        provider?: {
+            uuids: () => Promise<string[]>;
+            delete: (uuid: string) => Promise<void>;
+            get: (uuid: string) => Promise<{
+                access: number;
+                data?: any;
+            }>;
+            set: (uuid: string, data: {
+                access: number;
+                data?: any;
+            }) => Promise<void>;
+        };
+    };
+    globalAdvice?: any | ConstructorType<any>;
+    noSuchRouteEndPointMappingThrow?: (rr: RequestResponse) => any;
+    transactionManagerFactory?: () => TransactionManager;
+    constructor({ serverOption, listen, filters, requestEndPoints, closeEndPoints, errorEndPoints, sessionOption, globalAdvice, fileUploadTempPath, noSuchRouteEndPointMappingThrow, transactionManagerFactory }?: {
+        serverOption?: ServerOptions | HttpsServerOption;
+        listen?: Listen;
+        filters?: (Filter | ConstructorType<Filter>)[];
+        requestEndPoints?: (EndPoint | ConstructorType<EndPoint>)[];
+        closeEndPoints?: (EndPoint | ConstructorType<EndPoint>)[];
+        errorEndPoints?: (EndPoint | ConstructorType<EndPoint>)[];
+        sessionOption?: {
+            key?: string;
+            expiredTime?: number;
+            provider?: {
+                uuids: () => Promise<string[]>;
+                delete: (uuid: string) => Promise<void>;
+                get: (uuid: string) => Promise<{
+                    access: number;
+                    data?: any;
+                }>;
+                set: (uuid: string, data: {
+                    access: number;
+                    data?: any;
+                }) => Promise<void>;
+            };
+        };
+        globalAdvice?: any | ConstructorType<any>;
+        fileUploadTempPath?: string;
+        noSuchRouteEndPointMappingThrow?: (rr: RequestResponse) => any;
+        transactionManagerFactory?: () => TransactionManager;
+    }, initSimOption?: InitOptionType);
+    get hostname(): string;
+    get port(): number;
+    get protocol(): "http" | "https";
+    get address(): string;
+    get isSecure(): boolean;
+}
+//# sourceMappingURL=HttpServerOption.d.ts.map

package/option/HttpServerOption.js

@@ -0,0 +1,35 @@
+import { SimOption } from '@dooboostore/simple-boot/SimOption';
+export class HttpServerOption extends SimOption {
+    constructor({ serverOption, listen, filters, requestEndPoints, closeEndPoints, errorEndPoints, sessionOption, globalAdvice, fileUploadTempPath, noSuchRouteEndPointMappingThrow, transactionManagerFactory } = {}, initSimOption) {
+        super(initSimOption);
+        this.serverOption = serverOption;
+        this.listen = Object.assign({ port: HttpServerOption.DEFAULT_PORT, hostname: HttpServerOption.DEFAULT_HOSTNAME }, listen);
+        this.filters = filters;
+        this.requestEndPoints = requestEndPoints;
+        this.closeEndPoints = closeEndPoints;
+        this.errorEndPoints = errorEndPoints;
+        this.sessionOption = Object.assign({ key: 'SBSESSIONID', expiredTime: 1000 * 60 * 30 }, sessionOption);
+        this.globalAdvice = globalAdvice;
+        this.fileUploadTempPath = fileUploadTempPath;
+        this.noSuchRouteEndPointMappingThrow = noSuchRouteEndPointMappingThrow;
+        this.transactionManagerFactory = transactionManagerFactory;
+    }
+    get hostname() {
+        return this.listen.hostname;
+    }
+    get port() {
+        return this.listen.port;
+    }
+    get protocol() {
+        return this.isSecure ? 'https' : 'http';
+    }
+    get address() {
+        return `${this.protocol}://${this.hostname}:${this.port}`;
+    }
+    get isSecure() {
+        return this.serverOption && 'key' in this.serverOption && 'cert' in this.serverOption;
+    }
+}
+HttpServerOption.DEFAULT_PORT = 8081;
+HttpServerOption.DEFAULT_HOSTNAME = '127.0.0.1';
+//# sourceMappingURL=HttpServerOption.js.map

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@dooboostore/simple-boot-http-server",
+  "version": "1.0.14",
+  "main": "dist/SimpleBootHttpServer.js",
+  "license": "MIT",
+  "description": "back end http server frameworks",
+  "files": [
+    "**/*.js",
+    "**/*.d.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "front",
+    "spa",
+    "SPA",
+    "module",
+    "front-end",
+    "framwork",
+    "node"
+  ],
+  "author": "dooboostore <dooboostore@gmail.com> (https://github.com/dooboostore)",
+  "contributors": [
+    "sewoo <sewooimda@nate.com> (https://github.com/sewoo)",
+    "SeoDH <adonis_84@naver.com> (https://github.com/SeoDH)",
+    "tkyung (https://github.com/tkyungDev)",
+    "Hoil-Gang (https://github.com/khl1154)",
+    "hwangsero (https://github.com/hwangsero)"
+  ],
+  "homepage": "https://github.com/dooboostore-develop/packages",
+  "bugs": {
+    "url": "https://github.com/dooboostore-develop/packages",
+    "email": "dooboostore@gmail.com"
+  },
+  "devDependencies": {
+    "@types/jest": "^26.0.23",
+    "@types/mime-types": "^2.1.1",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^4.16.1",
+    "@typescript-eslint/parser": "^4.16.1",
+    "eslint": "^7.21.0",
+    "eslint-config-standard": "^16.0.2",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^4.3.1",
+    "jest": "^26.6.3",
+    "nodemon": "^2.0.15",
+    "supertest": "^6.1.3",
+    "ts-jest": "^26.5.4",
+    "ts-node": "^10.0.0",
+    "ts-node-dev": "^1.1.8",
+    "tsconfig-paths": "^3.9.0",
+    "typescript": "^4.4.3"
+  },
+  "dependencies": {
+    "@types/node-gzip": "^1.1.0",
+    "fast-json-patch": "^3.1.0",
+    "mime-types": "^2.1.34",
+    "node-gzip": "^1.1.2",
+    "reflect-metadata": "^0.2.2",
+    "canvas": "^3.1.0",
+    "@dooboostore/core": "1.0.7",
+    "@dooboostore/core-node": "1.0.1",
+    "@dooboostore/core-web": "1.0.1",
+    "@dooboostore/dom-render": "1.0.99",
+    "@dooboostore/simple-boot": "1.0.43"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "clean": "rm -rf  dist",
+    "npm:build": "pnpm run build && cp README.MD dist/ && pnpm pack && TARBALL_NAME=$(ls dooboostore-simple-boot-http-server-*.tgz | head -n 1) && tar -xzf \"$TARBALL_NAME\" -C dist --strip-components=1 package/package.json && rm \"$TARBALL_NAME\"",
+    "npm:clean": "rm -rf  dist",
+    "npm:publish": "pnpm run npm:build && cd dist && pnpm publish --no-git-checks",
+    "npm:publish:clean": "pnpm run npm:publish && rm -rf dist",
+    "ts:clean": "find . -name '*.js' -o -name '*.map' -o -name '*.d.ts' | xargs rm -f",
+    "tsc": "tsc",
+    "tsc:watch": "rm -rf ./dist && mkdir dist && cp package.json dist && tsc --watch --sourceMap true",
+    "tsc:watch:prod": "rm -rf dist && mkdir dist && cp package-prod.json dist/package.json && cp README.MD dist && tsc --watch --outDir dist --declarationDir dist",
+    "test": "jest --detectOpenHandles --forceExit",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/resolvers/Resolver.d.ts

@@ -0,0 +1,5 @@
+import { RequestResponse } from '../models/RequestResponse';
+export interface Resolver<T = any> {
+    resolve(data: T, rr: RequestResponse): Promise<void>;
+}
+//# sourceMappingURL=Resolver.d.ts.map

package/resolvers/Resolver.js

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

package/resolvers/ResourceResorver.d.ts

@@ -0,0 +1,6 @@
+import { Resolver } from './Resolver';
+import { RequestResponse } from '../models/RequestResponse';
+export declare class ResourceResorver implements Resolver {
+    resolve(data: string | undefined, rr: RequestResponse): Promise<void>;
+}
+//# sourceMappingURL=ResourceResorver.d.ts.map

package/resolvers/ResourceResorver.js

@@ -0,0 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Resource } from '../models/datas/Resource';
+import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
+let ResourceResorver = class ResourceResorver {
+    resolve(data, rr) {
+        return new Resource(data !== null && data !== void 0 ? data : rr).write(rr);
+    }
+};
+ResourceResorver = __decorate([
+    Sim
+], ResourceResorver);
+export { ResourceResorver };
+//# sourceMappingURL=ResourceResorver.js.map

package/session/SessionManager.d.ts

@@ -0,0 +1,57 @@
+import { HttpServerOption } from '../option/HttpServerOption';
+import { RequestResponse } from '../models/RequestResponse';
+export declare class SessionManager {
+    private option;
+    private sessions;
+    sessionOption: {
+        key: string;
+        expiredTime: number;
+        provider?: {
+            uuids: () => Promise<string[]>;
+            delete: (uuid: string) => Promise<void>;
+            get: (uuid: string) => Promise<{
+                access: number;
+                data?: any;
+            }>;
+            set: (uuid: string, data: {
+                access: number;
+                data?: any;
+            }) => Promise<void>;
+        };
+    };
+    constructor(option: HttpServerOption);
+    getSessionUUIDs(): Promise<string[]>;
+    deleteSession(uuid: string): Promise<void>;
+    getSessionDataSet(uuid: string): Promise<{
+        access: number;
+        data?: any;
+    }>;
+    setSessionDataSet(uuid: string, dataSet: {
+        access: number;
+        data?: any;
+    }): Promise<void>;
+    isExpired(access: number, now?: number): boolean;
+    makeUUID(): string;
+    session(): Promise<{
+        uuid: string;
+        dataSet: {
+            access: number;
+            data?: any;
+        };
+    }>;
+    session(uuid: string): Promise<{
+        uuid: string;
+        dataSet: {
+            access: number;
+            data?: any;
+        };
+    }>;
+    session(rr: RequestResponse): Promise<{
+        uuid: string;
+        dataSet: {
+            access: number;
+            data?: any;
+        };
+    }>;
+}
+//# sourceMappingURL=SessionManager.d.ts.map

package/session/SessionManager.js

@@ -0,0 +1,108 @@
+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 { RandomUtils } from '@dooboostore/core/random/RandomUtils';
+import { RequestResponse } from '../models/RequestResponse';
+export class SessionManager {
+    constructor(option) {
+        this.option = option;
+        this.sessions = new Map();
+        this.sessionOption = option.sessionOption;
+        setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            const uuids = (yield this.getSessionUUIDs());
+            for (const uuid of uuids) {
+                const dataSet = yield this.getSessionDataSet(uuid);
+                if (dataSet && this.isExpired(dataSet.access)) {
+                    yield this.deleteSession(uuid);
+                }
+            }
+        }), this.sessionOption.expiredTime);
+    }
+    getSessionUUIDs() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_a = this.sessionOption.provider) === null || _a === void 0 ? void 0 : _a.uuids) {
+                return this.sessionOption.provider.uuids();
+            }
+            else {
+                return Array.from(this.sessions.keys());
+            }
+        });
+    }
+    deleteSession(uuid) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_a = this.sessionOption.provider) === null || _a === void 0 ? void 0 : _a.delete) {
+                this.sessionOption.provider.delete(uuid);
+            }
+            else {
+                this.sessions.delete(uuid);
+            }
+        });
+    }
+    getSessionDataSet(uuid) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_a = this.sessionOption.provider) === null || _a === void 0 ? void 0 : _a.get) {
+                return this.sessionOption.provider.get(uuid);
+            }
+            else {
+                return this.sessions.get(uuid);
+            }
+        });
+    }
+    setSessionDataSet(uuid, dataSet) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_a = this.sessionOption.provider) === null || _a === void 0 ? void 0 : _a.set) {
+                this.sessionOption.provider.set(uuid, dataSet);
+            }
+            else {
+                this.sessions.set(uuid, dataSet);
+            }
+        });
+    }
+    isExpired(access, now = Date.now()) {
+        return (now - access) >= this.option.sessionOption.expiredTime;
+    }
+    makeUUID() {
+        return RandomUtils.uuid('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');
+    }
+    session(rrOrUUID) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let uuid;
+            if (rrOrUUID instanceof RequestResponse) {
+                uuid = (_a = rrOrUUID.reqCookieGet(this.sessionOption.key)) !== null && _a !== void 0 ? _a : this.makeUUID();
+            }
+            else if (typeof rrOrUUID === 'string') {
+                uuid = rrOrUUID;
+            }
+            else {
+                uuid = this.makeUUID();
+            }
+            let dataSet = yield this.getSessionDataSet(uuid);
+            const now = Date.now();
+            if (dataSet) {
+                if (this.isExpired(dataSet.access, now)) {
+                    delete dataSet.data;
+                }
+                dataSet.access = now;
+            }
+            else {
+                dataSet = {
+                    access: now
+                };
+            }
+            yield this.setSessionDataSet(uuid, dataSet);
+            return { uuid, dataSet };
+        });
+    }
+}
+//# sourceMappingURL=SessionManager.js.map