@dooboostore/simple-boot-http-server-ssr 1.0.8

package/README.MD

@@ -0,0 +1,215 @@
+# SIMPLE-BOOT-HTTP-SSR
+
+### A framework for building Server-Side Rendered (SSR) applications.
+
+This package seamlessly integrates `@dooboostore/simple-boot-front` and `@dooboostore/simple-boot-http-server` to provide a powerful solution for building fast, SEO-friendly, and dynamic web applications.
+
+- **Server-Side Rendering**: Renders your single-page application on the server before sending it to the client.
+- **JSDOM Integration**: Uses `jsdom` to create a virtual DOM environment on the server, allowing front-end code to run.
+- **Component Pooling**: Manages a pool of `SimpleBootFront` instances to handle concurrent SSR requests efficiently.
+- **Data Hydration**: Automatically serializes data fetched on the server and hydrates it on the client, avoiding redundant API calls. The `SaveAroundAfter` and `LoadAroundBefore` decorators facilitate this by saving data to `window.server_side_data` on the server and retrieving it on the client.
+- **Unified Codebase**: Enables sharing of routing, services, and components between the server and the client.
+- **Intent-based Communication**: Provides a mechanism for client-server communication using custom HTTP headers and intent publishing, allowing for flexible data fetching and action triggering.
+
+### Dependencies
+
+- **@dooboostore/simple-boot-front**: The front-end framework for building components and managing UI state.
+- **@dooboostore/simple-boot-http-server**: The underlying HTTP server for handling requests.
+
+## 🚀 How It Works
+
+The core of this package is the `SSRFilter`. When a request for an HTML page comes in, the filter does the following:
+
+1.  **Intercepts the Request**: It captures the request before it would normally serve a static `index.html` file.
+2.  **Acquires a Browser Environment**: It takes a pre-initialized `jsdom` instance from a pool. This instance acts as a virtual browser on the server.
+3.  **Initializes a Front-End App**: It uses a `SimpleBootFront` application instance (also from a pool) and sets its context to the `jsdom` window.
+4.  **Executes Routing**: It triggers the front-end router within the `jsdom` environment, using the path from the incoming request.
+5.  **Renders Components**: The front-end components render into the virtual DOM.
+6.  **Handles Data Fetching**: If components fetch data during their lifecycle, this happens on the server. The `SaveAroundAfter` and `LoadAroundBefore` decorators automatically handle the serialization of this data into `window.server_side_data`.
+7.  **Serializes the DOM**: Once rendering is complete, it captures the `outerHTML` of the `jsdom` document.
+8.  **Injects Hydration Data**: The serialized data from step 6 is injected into the HTML inside a `<script>` tag.
+9.  **Sends Response**: The fully rendered HTML is sent to the client.
+
+The client-side application then boots up, sees the pre-rendered HTML and the hydration data, and takes over without needing to re-render the initial view or re-fetch the initial data.
+
+Additionally, the `IntentSchemeFilter` handles specific client-server communication. When a request with `Accept: application/json-post+simple-boot-ssr-intent-scheme` and `X-Simple-Boot-Ssr-Intent-Scheme` headers is received, this filter intercepts it, publishes an intent, and returns the result, enabling a robust intent-based API.
+
+# 😃 Example Setup
+
+### Common Factory (`factory.ts`)
+
+This factory is used by both the server (for SSR) and the client (for browser rendering).
+
+```typescript
+import { SimpleBootHttpSSRFactory, SimFrontOption, SimpleBootFront } from '@dooboostore/simple-boot-http-server-ssr';
+import { ConstructorType } from '@dooboostore/core';
+import { IndexRouterComponent } from './components/index.router.component';
+
+// Function to create a standard front-end option object
+export const MakeSimFrontOption = (window: any): SimFrontOption => {
+    return new SimFrontOption(window).setUrlType('path');
+}
+
+// The factory class that creates instances of the front-end application
+class Factory extends SimpleBootHttpSSRFactory {
+    factory(simFrontOption: SimFrontOption, using: ConstructorType<any>[] = [], domExcludes: ConstructorType<any>[] = []): Promise<SimpleBootFront> {
+        const simpleBootFront = new SimpleBootFront(IndexRouterComponent, simFrontOption);
+        // Exclude certain types from being proxied by the DOM renderer
+        simpleBootFront.domRendoerExcludeProxy.push(...domExcludes);
+        return Promise.resolve(simpleBootFront);
+    }
+}
+
+export default new Factory();
+```
+
+### Server Entry Point (`server.ts`)
+
+This sets up the HTTP server with the `SSRFilter` and `IntentSchemeFilter`.
+
+```typescript
+import 'reflect-metadata';
+import { ConstructorType } from '@dooboostore/core/types';
+import { SimpleBootHttpSSRServer } from '@dooboostore/simple-boot-http-server-ssr/SimpleBootHttpSSRServer';
+import { HttpSSRServerOption } from '@dooboostore/simple-boot-http-server-ssr/option/HttpSSRServerOption';
+import { environment } from './environments/environment';
+import { NotFoundError } from '@dooboostore/simple-boot-http-server/errors/NotFoundError';
+import { SimpleBootHttpServer } from '@dooboostore/simple-boot-http-server/SimpleBootHttpServer';
+import Factory, { MakeSimFrontOption } from '@src/bootfactory';
+import { FactoryAndParams, SSRFilter } from '@dooboostore/simple-boot-http-server-ssr/filters/SSRFilter';
+import { ResourceFilter } from '@dooboostore/simple-boot-http-server/filters/ResourceFilter';
+import { RootRouter } from '@backend/root.router';
+import { RequestResponse } from '@dooboostore/simple-boot-http-server/models/RequestResponse';
+import { DataSource } from 'typeorm';
+import { DatabaseService } from '@backend/service/database/DatabaseService';
+import { services } from '@backend/service';
+import { IntentSchemeFilter } from '@dooboostore/simple-boot-http-server-ssr/filters/IntentSchemeFilter';
+import { ErrorLogEndPoint } from '@backend/endpoints/ErrorLogEndPoint';
+import { CloseLogEndPoint } from '@backend/endpoints/CloseLogEndPoint';
+import { RequestLogEndPoint } from '@backend/endpoints/RequestLogEndPoint';
+import { GlobalAdvice } from '@backend/advices/GlobalAdvice';
+import { SimpleBootHttpSSRFactory } from '@dooboostore/simple-boot-http-server-ssr/SimpleBootHttpSSRFactory';
+import { Runnable } from '@dooboostore/core/runs/Runnable';
+import { CrossDomainHeaderEndPoint } from '@dooboostore/simple-boot-http-server/endpoints/CrossDomainHeaderEndPoint';
+import { SyncManager } from '@backend/manager';
+import { SecurityService } from '@backend/service/SecurityService';
+
+type ENV_MODE = 'ONLY_SYNC' | 'NO_SYNC' | undefined;
+type WORLD = undefined | string;
+
+type RunParams = { mode: ENV_MODE, world: WORLD };
+
+class Server implements Runnable<void, RunParams> {
+  async run(config?: RunParams) {
+    const securityService = new SecurityService();
+    const databaseService = new DatabaseService(securityService);
+    await databaseService.run();
+    if (mode !== 'NO_SYNC') {
+      const syncManager = new SyncManager(databaseService);
+      await syncManager.run(config?.world ? Number(config.world) : undefined);
+    }
+
+    if (mode === 'ONLY_SYNC') {
+      return;
+    }
+
+
+    // const cacheManager = new CacheManager(databaseService);
+    // await cacheManager.run();
+
+    const otherInstanceSim = new Map<ConstructorType<any>, any>();
+    otherInstanceSim.set(SecurityService, securityService);
+    otherInstanceSim.set(DatabaseService, databaseService);
+    // otherInstanceSim.set(CacheManager, cacheManager);
+
+    const ssrOption: FactoryAndParams = {
+      frontDistPath: environment.frontDistPath,
+      frontDistIndexFileName: environment.frontDistIndexFileName,
+      factorySimFrontOption: (window: any) => MakeSimFrontOption(window),
+      factory: Factory as SimpleBootHttpSSRFactory,
+      poolOption: {
+        max: 50,
+        min: 5
+      },
+      using: [...services],
+      domExcludes: [DataSource] as ConstructorType<any>[],
+      ssrExcludeFilter: (rr: RequestResponse) => {
+        const firstExcludeFilter = [
+          /^\/signs\/confirm-email.*/,
+          /^\/assets\/.*/,
+          /^\/api\/.*/
+        ];
+        for (const excludeRegExp of firstExcludeFilter) {
+          if (excludeRegExp.test(rr.reqUrl)) {
+            return true;
+          }
+        }
+        return false;
+      },
+      simpleBootFront: {
+        notFoundError: true
+      }
+    };
+    // const ssrFilter = new SSRFilter(ssrOption, otherInstanceSim);
+
+    const resourceFilter = new ResourceFilter(environment.frontDistPath,
+      [
+        'assets/privacy.html', 'assets/.*', '\.js$', '\.map$', '\.ico$', '\.png$', '\.jpg$', '\.jpeg$', '\.gif$', 'offline\.html$', 'webmanifest$', 'manifest\.json', 'service-worker\.js$', 'googlebe4b1abe81ab7cf3\.html$',
+        {
+          request: (rr) => {
+            return RegExp('/.*').test(rr.reqUrlPathName) && rr.reqMethod()?.toUpperCase() === 'GET';
+          },
+          dist: 'index.html'
+        }
+      ]
+    );
+    const uploadResourceFilter = new ResourceFilter(environment.uploadTempPath,
+      ['public/.*']
+    );
+
+    const option = new HttpSSRServerOption();
+    option.cache = {
+      enable: true
+    }
+    option.rootRouter = RootRouter;
+    option.listen = environment.httpServerConfig.listen;
+    option.globalAdvice = new GlobalAdvice();
+    option.requestEndPoints = [
+      new RequestLogEndPoint(),
+      new CrossDomainHeaderEndPoint({accessControlExposeHeaders: 'Set-Cookie', accessControlAllowHeaders: '*', accessControlAllowMethods: '*', accessControlAllowOrigin: '*'}),
+    ];
+    option.closeEndPoints = [new CloseLogEndPoint()];
+    option.errorEndPoints = [new ErrorLogEndPoint()];
+    option.noSuchRouteEndPointMappingThrow = () => new NotFoundError();
+    option.fileUploadTempPath = environment.uploadTempPath;
+    option.filters = [
+      resourceFilter,
+      uploadResourceFilter,
+      // ssrFilter,
+      // SecurityFilter,
+      IntentSchemeFilter
+    ];
+    // option.serverOption = {
+    //  key: fs.readFileSync(path.resolve(__dirname, '../data/certificates/localhost-key.pem')),
+    //  cert: fs.readFileSync(path.resolve(__dirname, '../data/certificates/localhost.pem')),
+    // }
+    option.listen.listeningListener = (server: SimpleBootHttpServer) => {
+      console.log(`http server startUP! listening on ${server.option.listen.port}`);
+    };
+
+    const ssr = new SimpleBootHttpSSRServer(option);
+    await ssr.run(otherInstanceSim);
+    return ssr;
+  }
+}
+
+const mode = process.env.MODE as ENV_MODE;
+const world = process.env.WORLD as ENV_MODE;
+new Server().run({mode, world}).then(ssr => {
+  console.log(`server started!! (mode:${mode})`);
+});
+console.log(`server wait... (mode:${mode})`);
+
+
+
+```

package/SimpleBootHttpSSRFactory.d.ts

@@ -0,0 +1,8 @@
+import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
+import { ConstructorType } from '@dooboostore/core/types';
+import { SimFrontOption } from '@dooboostore/simple-boot-front/option/SimFrontOption';
+export declare abstract class SimpleBootHttpSSRFactory {
+    abstract factory(simFrontOption: SimFrontOption, using: (ConstructorType<any> | Function)[], domExcludes: ConstructorType<any>[]): Promise<SimpleBootFront>;
+    create(simFrontOption: SimFrontOption, using?: (ConstructorType<any> | Function)[], domExcludes?: ConstructorType<any>[]): Promise<SimpleBootFront>;
+}
+//# sourceMappingURL=SimpleBootHttpSSRFactory.d.ts.map

package/SimpleBootHttpSSRFactory.js

@@ -0,0 +1,10 @@
+import { __awaiter } from "tslib";
+export class SimpleBootHttpSSRFactory {
+    create(simFrontOption, using = [], domExcludes = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const front = yield this.factory(simFrontOption, using, domExcludes);
+            return front;
+        });
+    }
+}
+//# sourceMappingURL=SimpleBootHttpSSRFactory.js.map

package/SimpleBootHttpSSRServer.d.ts

@@ -0,0 +1,9 @@
+import { SimpleBootHttpServer } from '@dooboostore/simple-boot-http-server/SimpleBootHttpServer';
+import { SimstanceManager } from '@dooboostore/simple-boot/simstance/SimstanceManager';
+import { HttpSSRServerOption } from './option/HttpSSRServerOption';
+import { ConstructorType } from '@dooboostore/core/types';
+export declare class SimpleBootHttpSSRServer extends SimpleBootHttpServer {
+    constructor(option?: HttpSSRServerOption);
+    run(otherInstanceSim?: Map<ConstructorType<any>, any>): SimstanceManager;
+}
+//# sourceMappingURL=SimpleBootHttpSSRServer.d.ts.map

package/SimpleBootHttpSSRServer.js

@@ -0,0 +1,12 @@
+import { SimpleBootHttpServer } from '@dooboostore/simple-boot-http-server/SimpleBootHttpServer';
+export class SimpleBootHttpSSRServer extends SimpleBootHttpServer {
+    constructor(option) {
+        super(option);
+    }
+    run(otherInstanceSim) {
+        const oi = new Map();
+        otherInstanceSim === null || otherInstanceSim === void 0 ? void 0 : otherInstanceSim.forEach((value, key) => oi.set(key, value));
+        return super.run(oi);
+    }
+}
+//# sourceMappingURL=SimpleBootHttpSSRServer.js.map

package/codes/HttpHeaders.d.ts

@@ -0,0 +1,45 @@
+import { HttpHeaders as AHttpHeaders } from '@dooboostore/simple-boot-http-server/codes/HttpHeaders';
+export declare const HttpHeaders: {
+    XSimpleBootSsrIntentScheme: string;
+    ContentLength: AHttpHeaders.ContentLength;
+    ContentType: AHttpHeaders.ContentType;
+    ContentEncoding: AHttpHeaders.ContentEncoding;
+    Accept: AHttpHeaders.Accept;
+    Authorization: AHttpHeaders.Authorization;
+    CacheControl: AHttpHeaders.CacheControl;
+    Connection: AHttpHeaders.Connection;
+    Date: AHttpHeaders.Date;
+    Host: AHttpHeaders.Host;
+    Pragma: AHttpHeaders.Pragma;
+    Trailer: AHttpHeaders.Trailer;
+    TransferEncoding: AHttpHeaders.TransferEncoding;
+    Upgrade: AHttpHeaders.Upgrade;
+    Via: AHttpHeaders.Via;
+    Warning: AHttpHeaders.Warning;
+    AcceptCharset: AHttpHeaders.AcceptCharset;
+    AcceptEncoding: AHttpHeaders.AcceptEncoding;
+    AcceptLanguage: AHttpHeaders.AcceptLanguage;
+    AccessControlAllowOrigin: AHttpHeaders.AccessControlAllowOrigin;
+    AccessControlAllowMethods: AHttpHeaders.AccessControlAllowMethods;
+    AccessControlAllowHeaders: AHttpHeaders.AccessControlAllowHeaders;
+    AccessControlExposeHeaders: AHttpHeaders.AccessControlExposeHeaders;
+    Expect: AHttpHeaders.Expect;
+    From: AHttpHeaders.From;
+    MaxForwards: AHttpHeaders.MaxForwards;
+    Referer: AHttpHeaders.Referer;
+    UserAgent: AHttpHeaders.UserAgent;
+    Cookie: AHttpHeaders.Cookie;
+    SetCookie: AHttpHeaders.SetCookie;
+    Cookie2: AHttpHeaders.Cookie2;
+    SetCookie2: AHttpHeaders.SetCookie2;
+    Location: AHttpHeaders.Location;
+    IfModifiedSince: AHttpHeaders.IfModifiedSince;
+    IfUnmodifiedSince: AHttpHeaders.IfUnmodifiedSince;
+    IfMatch: AHttpHeaders.IfMatch;
+    IfNoneMatch: AHttpHeaders.IfNoneMatch;
+    IfRange: AHttpHeaders.IfRange;
+    Allow: AHttpHeaders.Allow;
+    Server: AHttpHeaders.Server;
+};
+export declare const makeIntentHeaderBySymbol: (symbol: Symbol) => HeadersInit;
+//# sourceMappingURL=HttpHeaders.d.ts.map

package/codes/HttpHeaders.js

@@ -0,0 +1,10 @@
+import { HttpHeaders as AHttpHeaders } from '@dooboostore/simple-boot-http-server/codes/HttpHeaders';
+import { Mimes } from './Mimes';
+export const HttpHeaders = Object.assign(Object.assign({}, AHttpHeaders), { XSimpleBootSsrIntentScheme: 'x-simple-boot-ssr-intent-scheme' });
+export const makeIntentHeaderBySymbol = (symbol) => {
+    return {
+        [HttpHeaders.Accept]: Mimes.ApplicationJsonPostSimpleBootSsrIntentScheme,
+        [HttpHeaders.XSimpleBootSsrIntentScheme]: `Symbol.for(${symbol.description})`
+    };
+};
+//# sourceMappingURL=HttpHeaders.js.map

package/codes/Mimes.d.ts

@@ -0,0 +1,31 @@
+import { Mimes as AMimes } from '@dooboostore/simple-boot-http-server/codes/Mimes';
+export declare const Mimes: {
+    ApplicationJsonPostSimpleBootSsrIntentScheme: string;
+    Intent: string;
+    ApplicationJson: AMimes.ApplicationJson;
+    ApplicationOctetStream: AMimes.ApplicationOctetStream;
+    ApplicationXml: AMimes.ApplicationXml;
+    ApplicationJsonPatch: AMimes.ApplicationJsonPatch;
+    ApplicationXWwwFormUrlencoded: AMimes.ApplicationXWwwFormUrlencoded;
+    TextPlain: AMimes.TextPlain;
+    TextHtml: AMimes.TextHtml;
+    All: AMimes.All;
+    TextCss: AMimes.TextCss;
+    TextJavascript: AMimes.TextJavascript;
+    TextXml: AMimes.TextXml;
+    TextXslt: AMimes.TextXslt;
+    TextXmlDtd: AMimes.TextXmlDtd;
+    TextPlainUtf8: AMimes.TextPlainUtf8;
+    ImagePng: AMimes.ImagePng;
+    ImageGif: AMimes.ImageGif;
+    ImageJpeg: AMimes.ImageJpeg;
+    ImageSvg: AMimes.ImageSvg;
+    ImageBmp: AMimes.ImageBmp;
+    ImageTiff: AMimes.ImageTiff;
+    ImagePdf: AMimes.ImagePdf;
+    ImageXBmp: AMimes.ImageXBmp;
+    ImageXpixmap: AMimes.ImageXpixmap;
+    ImageXxbm: AMimes.ImageXxbm;
+    MultipartFormData: AMimes.MultipartFormData;
+};
+//# sourceMappingURL=Mimes.d.ts.map

package/codes/Mimes.js

@@ -0,0 +1,3 @@
+import { Mimes as AMimes } from '@dooboostore/simple-boot-http-server/codes/Mimes';
+export const Mimes = Object.assign(Object.assign({}, AMimes), { ApplicationJsonPostSimpleBootSsrIntentScheme: 'application/json-post+simple-boot-ssr-intent-scheme', Intent: 'intent' });
+//# sourceMappingURL=Mimes.js.map

package/decorators/LoadAroundBefore.d.ts

@@ -0,0 +1,2 @@
+export declare const LoadAroundBefore: (obj: any, propertyKey: string, args: any[]) => any[];
+//# sourceMappingURL=LoadAroundBefore.d.ts.map

package/decorators/LoadAroundBefore.js

@@ -0,0 +1,31 @@
+import { getSim } from '@dooboostore/simple-boot/decorators/SimDecorator';
+import { AroundForceReturn } from '@dooboostore/simple-boot/decorators/aop/AOPDecorator';
+import { ReflectUtils } from '@dooboostore/simple-boot/utils/reflect/ReflectUtils';
+export const LoadAroundBefore = (obj, propertyKey, args) => {
+    var _a, _b, _c;
+    const simstanceManager = obj._SimpleBoot_simstanceManager;
+    const simOption = obj._SimpleBoot_simOption;
+    const config = getSim(obj);
+    if (simstanceManager && simOption && (config === null || config === void 0 ? void 0 : config.scheme)) {
+        const key = config.scheme + '_' + propertyKey;
+        const type = ReflectUtils.getReturnType(obj, propertyKey);
+        const isHas = (key in ((_a = simOption.window.server_side_data) !== null && _a !== void 0 ? _a : {}));
+        if (isHas) {
+            const data = (_b = simOption.window.server_side_data) === null || _b === void 0 ? void 0 : _b[key];
+            (_c = simOption.window.server_side_data) === null || _c === void 0 ? true : delete _c[key];
+            let rdata;
+            if (type === Promise) {
+                rdata = Promise.resolve(data);
+            }
+            else {
+                rdata = data;
+            }
+            throw new AroundForceReturn(rdata);
+        }
+        else {
+            return args;
+        }
+    }
+    return args;
+};
+//# sourceMappingURL=LoadAroundBefore.js.map

package/decorators/SaveAroundAfter.d.ts

@@ -0,0 +1,3 @@
+export declare const SaveAroundAfter: (obj: any, propertyKey: string, args: any[], beforeReturn: any) => any;
+export declare const getStorage: (window: Window) => any;
+//# sourceMappingURL=SaveAroundAfter.d.ts.map

package/decorators/SaveAroundAfter.js

@@ -0,0 +1,26 @@
+import { getSim } from '@dooboostore/simple-boot/decorators/SimDecorator';
+export const SaveAroundAfter = (obj, propertyKey, args, beforeReturn) => {
+    const simstanceManager = obj._SimpleBoot_simstanceManager;
+    const simOption = obj._SimpleBoot_simOption;
+    const config = getSim(obj);
+    if (simstanceManager && simOption && (config === null || config === void 0 ? void 0 : config.scheme)) {
+        if (!simOption.window.server_side_data) {
+            simOption.window.server_side_data = {};
+        }
+        const key = config.scheme + '_' + propertyKey;
+        if (beforeReturn instanceof Promise) {
+            beforeReturn.then((it) => {
+                simOption.window.server_side_data[key] = JSON.stringify(it);
+                return it;
+            });
+        }
+        else {
+            simOption.window.server_side_data[key] = JSON.stringify(beforeReturn);
+        }
+    }
+    return beforeReturn;
+};
+export const getStorage = (window) => {
+    return window.aroundStorage;
+};
+//# sourceMappingURL=SaveAroundAfter.js.map

package/filters/IntentSchemeFilter.d.ts

@@ -0,0 +1,20 @@
+import { Filter } from '@dooboostore/simple-boot-http-server/filters/Filter';
+import { IntentManager } from '@dooboostore/simple-boot/intent/IntentManager';
+import { RequestResponse } from '@dooboostore/simple-boot-http-server/models/RequestResponse';
+import { SimpleBootHttpServer } from '@dooboostore/simple-boot-http-server/SimpleBootHttpServer';
+export declare class IntentSchemeFilter implements Filter {
+    private intentManager;
+    constructor(intentManager: IntentManager);
+    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=IntentSchemeFilter.d.ts.map

package/filters/IntentSchemeFilter.js

@@ -0,0 +1,72 @@
+import { __awaiter, __decorate, __metadata } from "tslib";
+import { HttpHeaders } from '../codes/HttpHeaders';
+import { Intent, PublishType } from '@dooboostore/simple-boot/intent/Intent';
+import { IntentManager } from '@dooboostore/simple-boot/intent/IntentManager';
+import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
+import { HttpStatus } from '@dooboostore/simple-boot-http-server/codes/HttpStatus';
+import { Mimes } from '../codes/Mimes';
+let IntentSchemeFilter = class IntentSchemeFilter {
+    constructor(intentManager) {
+        this.intentManager = intentManager;
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    proceedBefore({ rr, app }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // const rr = rrr;
+            const url = rr.reqUrl;
+            const contentLength = Number(rr.reqHeader((_a = HttpHeaders.ContentLength.toLowerCase()) !== null && _a !== void 0 ? _a : '0'));
+            const acceptType = rr.reqHeader(HttpHeaders.Accept);
+            const contentType = rr.reqHeader(HttpHeaders.ContentType);
+            const intentScheme = rr.reqHeader(HttpHeaders.XSimpleBootSsrIntentScheme);
+            if (acceptType === Mimes.ApplicationJsonPostSimpleBootSsrIntentScheme && intentScheme) {
+                let intent = new Intent(`${intentScheme}:/${url}`);
+                intent.publishType = PublishType.INLINE_DATA_PARAMETERS;
+                // const responseHeader = {} as any;
+                // responseHeader[HttpHeaders.ContentType] = Mimes.ApplicationJson;
+                if (contentLength > 0) {
+                    if (contentType.includes(Mimes.ApplicationJson)) {
+                        intent.data = [yield rr.reqBodyJsonData(), rr];
+                    }
+                    else if (contentType.includes(Mimes.MultipartFormData)) {
+                        intent.data = [yield rr.reqBodyMultipartFormDataObject(), rr];
+                    }
+                    const rdatas = this.intentManager.publish(intent);
+                    const rdata = rdatas[0];
+                    const wdata = rdata instanceof Promise ? yield rdata : rdata;
+                    rr.resStatusCode(HttpStatus.Ok);
+                    rr.resSetHeader(HttpHeaders.ContentType, [Mimes.ApplicationJson]);
+                    yield rr.resEnd(wdata ? JSON.stringify(wdata) : undefined);
+                }
+                else {
+                    intent.data = rr.reqUrlSearchParamTuples.length > 0 ? [rr.reqUrlSearchParamsObj, rr] : [rr];
+                    const rdatas = this.intentManager.publish(intent);
+                    const rdata = rdatas[0];
+                    const wdata = rdata instanceof Promise ? yield rdata : rdata;
+                    rr.resStatusCode(HttpStatus.Ok);
+                    rr.resSetHeader(HttpHeaders.ContentType, [Mimes.ApplicationJson]);
+                    yield rr.resEnd(wdata ? JSON.stringify(wdata) : undefined);
+                }
+                // console.log('---------3--intent request', rr.req.readable, rr.req.readableLength);
+                return false;
+            }
+            else {
+                return true;
+            }
+        });
+    }
+    proceedAfter({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+};
+IntentSchemeFilter = __decorate([
+    Sim,
+    __metadata("design:paramtypes", [IntentManager])
+], IntentSchemeFilter);
+export { IntentSchemeFilter };
+//# sourceMappingURL=IntentSchemeFilter.js.map

package/filters/SSRFilter.d.ts

@@ -0,0 +1,54 @@
+import { RequestResponse } from '@dooboostore/simple-boot-http-server/models/RequestResponse';
+import { SimpleBootHttpSSRFactory } from '../SimpleBootHttpSSRFactory';
+import { ConstructorType } from '@dooboostore/core/types';
+import { Filter } from '@dooboostore/simple-boot-http-server/filters/Filter';
+import { HttpStatus } from '@dooboostore/simple-boot-http-server/codes/HttpStatus';
+import { SimpleBootHttpServer } from '@dooboostore/simple-boot-http-server/SimpleBootHttpServer';
+import { SimFrontOption } from '@dooboostore/simple-boot-front/option/SimFrontOption';
+import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
+import * as JSDOM from 'jsdom';
+export type FactoryAndParams = {
+    frontDistPath: string;
+    frontDistIndexFileName?: string;
+    factorySimFrontOption: (window: any) => SimFrontOption;
+    factory: SimpleBootHttpSSRFactory;
+    poolOption: {
+        max: number;
+        min: number;
+    };
+    using: ConstructorType<any>[];
+    domExcludes: ConstructorType<any>[];
+    ssrExcludeFilter?: (rr: RequestResponse) => boolean;
+    simpleBootFront?: {
+        notFoundError?: boolean;
+    };
+};
+export declare class SSRFilter implements Filter {
+    config: FactoryAndParams;
+    otherInstanceSim?: Map<ConstructorType<any>, any>;
+    private simpleBootFrontPool;
+    private simpleBootFrontQueue;
+    private indexHTML;
+    private welcomUrl;
+    constructor(config: FactoryAndParams, otherInstanceSim?: Map<ConstructorType<any>, any>);
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+    makeJsdom(): Promise<JSDOM.JSDOM>;
+    makeFront(jsdom: JSDOM.JSDOM): Promise<SimpleBootFront>;
+    enqueueFrontApp(simpleBootFront: SimpleBootFront): void;
+    pushQueue(): Promise<void>;
+    proceedBefore({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+    writeOkHtmlAndEnd({ rr, status }: {
+        rr: RequestResponse;
+        status?: HttpStatus;
+    }, html: string): Promise<void>;
+    proceedAfter({ rr, app }: {
+        rr: RequestResponse;
+        app: SimpleBootHttpServer;
+        carrier: Map<string, any>;
+    }): Promise<boolean>;
+}
+//# sourceMappingURL=SSRFilter.d.ts.map

package/filters/SSRFilter.js

@@ -0,0 +1,221 @@
+import { __awaiter } from "tslib";
+import { HttpHeaders } from '@dooboostore/simple-boot-http-server/codes/HttpHeaders';
+import { JsdomInitializer } from '../initializers/JsdomInitializer';
+import { Mimes } from '@dooboostore/simple-boot-http-server/codes/Mimes';
+import { HttpStatus } from '@dooboostore/simple-boot-http-server/codes/HttpStatus';
+import { AsyncBlockingQueue } from '@dooboostore/core/queues/AsyncBlockingQueue';
+import { RandomUtils } from '@dooboostore/core/random/RandomUtils';
+import { NotFoundError } from '@dooboostore/simple-boot-http-server/errors/NotFoundError';
+export class SSRFilter {
+    constructor(config, otherInstanceSim) {
+        this.config = config;
+        this.otherInstanceSim = otherInstanceSim;
+        this.simpleBootFrontPool = [];
+        this.simpleBootFrontQueue = new AsyncBlockingQueue();
+        this.welcomUrl = 'http://localhost';
+        config.frontDistIndexFileName = config.frontDistIndexFileName || 'index.html';
+        this.indexHTML = JsdomInitializer.loadFile(this.config.frontDistPath, config.frontDistIndexFileName);
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < this.config.poolOption.min; i++) {
+                yield this.pushQueue();
+            }
+            // console.log('SimpleBootHttpSSRFactory init success ', + this.simpleBootFrontPool.length)
+        });
+    }
+    // workerTs(workerOptions: WorkerOptions) {
+    //     workerOptions.eval = true;
+    //     if (!workerOptions.workerData) {
+    //         workerOptions.workerData = {};
+    //     }
+    //     workerOptions.workerData.__filename = '/Users/hyunhakim/source/visualkhh/pet-space/libs/simple-boot-http-ssr/dist/filters/SSRCreatorWorker.js';
+    //     return new Worker(` const wk = require('worker_threads'); require('ts-node').register(); let file = wk.workerData.__filename; require(file); `, workerOptions,);
+    // }
+    makeJsdom() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const jsdom = yield new JsdomInitializer(this.config.frontDistPath, this.config.frontDistIndexFileName || 'index.html', { url: this.welcomUrl }).run();
+            return jsdom;
+        });
+    }
+    makeFront(jsdom) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = RandomUtils.uuid();
+            // const jsdom = await this.makeJsdom();
+            const window = jsdom.window;
+            window.ssrUse = false;
+            const option = this.config.factorySimFrontOption(window);
+            const simpleBootFront = yield this.config.factory.create(option, this.config.using, this.config.domExcludes);
+            simpleBootFront.run(this.otherInstanceSim);
+            simpleBootFront.jsdom = jsdom;
+            return simpleBootFront;
+        });
+    }
+    enqueueFrontApp(simpleBootFront) {
+        // this.simpleBootFrontPool.set(simpleBootFront.option.name!, simpleBootFront);
+        this.simpleBootFrontPool.push(simpleBootFront);
+        this.simpleBootFrontQueue.enqueue(simpleBootFront);
+    }
+    // async pushQueue(destorFront?: SimpleBootFront) {
+    //     if (destorFront) {
+    //         this.simpleBootFrontPool.delete(destorFront.option.name!);
+    //     }
+    pushQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.simpleBootFrontPool.length < this.config.poolOption.max) {
+                this.enqueueFrontApp(yield this.makeFront(yield this.makeJsdom()));
+            }
+        });
+    }
+    proceedBefore({ rr, app }) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_b = (_a = this.config).ssrExcludeFilter) === null || _b === void 0 ? void 0 : _b.call(_a, rr)) {
+                return false;
+            }
+            if ((rr.reqHasAcceptHeader(Mimes.TextHtml) || rr.reqHasAcceptHeader(Mimes.All))) {
+                if (this.simpleBootFrontQueue.isEmpty()) {
+                    yield this.pushQueue();
+                }
+                const simpleBootFront = yield this.simpleBootFrontQueue.dequeue();
+                try {
+                    // console.log('SSRFilter before-->' , simpleBootFront.option.name, 'poolLength:',this.simpleBootFrontPool.size);
+                    simpleBootFront.option.window.ssrUse = true;
+                    delete simpleBootFront.option.window.server_side_data;
+                    const url = rr.reqUrlObj({ host: 'localhost' });
+                    if ((_c = this.config.simpleBootFront) === null || _c === void 0 ? void 0 : _c.notFoundError) {
+                        // intent router check first
+                        const intent = yield simpleBootFront.getIntent(url.pathname);
+                        // route를 못찾은상태에서 router path까지 안맞으면 404 처리한다.  route랑 router랑 다르니깐 헛갈리지말도록
+                        if (intent.module === undefined && (!intent.getRouterPathData(rr.reqUrlPathName))) {
+                            throw new NotFoundError({ message: `Not Found: ${rr.reqUrlPathName}` });
+                        }
+                    }
+                    // runRouting!!
+                    simpleBootFront.goRouting(url.toString());
+                    // console.log('------intent', intent)
+                    yield new Promise((r) => setTimeout(r, 0)); // <--중요: 이거 넣어야지 두번불러지는게 없어지는듯? 뭐지 event loop 변경된건가?
+                    // const e = Expression.Path.pathNameData(rr.reqUrlPathName, intent.getRouterPath())
+                    // console.log('------intent', rr.reqUrl, rr.reqUrlPathName, intent.module, intent.getRouterPath(), e)
+                    let html = simpleBootFront.option.window.document.documentElement.outerHTML;
+                    const serverSideData = simpleBootFront.option.window.server_side_data;
+                    if (serverSideData) {
+                        const data = Object.entries(serverSideData).map(([k, v]) => {
+                            if (typeof v === 'string') {
+                                return `window.server_side_data.${k} = ${v}`;
+                            }
+                            else {
+                                return `window.server_side_data.${k} = ${JSON.stringify(v)}`;
+                            }
+                        }).join(';');
+                        if (data) {
+                            html = html.replace('</head>', `<script> window.server_side_data={}; ${data}; </script></head>`);
+                        }
+                    }
+                    yield this.writeOkHtmlAndEnd({ rr }, html);
+                }
+                finally {
+                    simpleBootFront.option.window.ssrUse = false;
+                    delete simpleBootFront.option.window.server_side_data;
+                    // console.log('--------->', simpleBootFront.option.window)
+                    // simpleBootFront.ninitWriteRootRouter();
+                    // ((simpleBootFront as any).jsdom as JSDOM.JSDOM)?.reconfigure({url: '/' });
+                    // simpleBootFront.option.window.location.href = 'about:blank';
+                    this.simpleBootFrontQueue.enqueue(simpleBootFront);
+                    // simpleBootFront.option.window.document.body.innerHTML = this.rootJSDOM.window.document.body.innerHTML;
+                    // simpleBootFront.writeRootRouter()
+                    // await simpleBootFront.goRouting('/');
+                    // ((simpleBootFront as any).jsdom as JSDOM.JSDOM)?.reconfigure({url: this.welcomUrl });
+                    // simpleBootFront.option.window.location.href = this.welcomUrl;
+                    // simpleBootFront.option.window.document.documentElement.outerHTML = this.indexHTML;
+                    // this.simpleBootFrontQueue.enqueue(simpleBootFront);
+                    // await new Promise((re, r) => setTimeout(() => re(true), 10000));
+                    // new Promise((re, r) => setTimeout(() => re(true), 10000)).then(it => {
+                    //     console.log('ddddddddddd')
+                    // });
+                    // this.simpleBootFrontPool.delete(simpleBootFront.option.name!);
+                    // if (isMainThread) { // 메인 스레드
+                    //     console.log('file-->', __filename)
+                    //     const worker = new Worker(__filename);
+                    //     worker.on('message', (value: any) => {
+                    //         console.log('워커로부터', value)
+                    //     })
+                    //     worker.on('exit', (value: any) => { // parentPort.close()가 일어나면 이벤트 발생
+                    //         console.log('워커 끝~');
+                    //     })
+                    //     worker.postMessage('ping'); // 워커스레드에게 메세지를 보낸다.
+                    // } else { // 워커스레드
+                    //     parentPort.on('message', (value: any) => {
+                    //         console.log("부모로부터", value);
+                    //         parentPort.postMessage('pong');
+                    //         parentPort.close(); // 워커스레드 종료라고 메인스레드에 알려줘야 exit이벤트 발생
+                    //     })
+                    // }
+                    //worker thrad
+                    // const workerPath = path.join(__dirname, 'SSRWorker.js');
+                    // const worker = new Worker(workerPath);
+                    // worker.once('message', (value: any) => {
+                    //     console.log('워커로부터', value)
+                    // });
+                    // const receiveWorker = new Worker('/Users/hyunhakim/source/visualkhh/pet-space/libs/simple-boot-http-ssr/dist/filters/SSRCreatorWorker.js');
+                    // receiveWorker.on('message', (msg: JSDOM.JSDOM)=>{
+                    //     console.log('워커로부터', msg, msg.window.document.body.innerHTML)
+                    //     console.log('a message is sent! : ', msg)
+                    //
+                    // });
+                    //
+                    // receiveWorker.on('error', err=>{
+                    //     console.error(err);
+                    // })
+                    //
+                    // receiveWorker.on('exit', ()=>console.log('exited!'));
+                    // receiveWorker.postMessage(
+                    //     {
+                    //         frontDistPath: this.factory.frontDistPath,
+                    //         frontDistIndexFileName: this.factory.frontDistIndexFileName,
+                    //     }
+                    // );
+                    // const myWorkers = this.workerTs({});
+                    // myWorkers.postMessage(this);
+                    // myWorkers.on('message', (value: SimpleBootFront) => {
+                    //     this.pushQueue(value);
+                    // })
+                    // this
+                    // this.pushQueue(simpleBootFront).then(it => {
+                    //     console.log('deee')
+                    // });
+                    // console.log('-1->', simpleBootFront.option.window.location.href);
+                    // simpleBootFront.option.window.location.href = this.welcomUrl;
+                    // simpleBootFront.option.window.location.reload();
+                    // console.log('-2->', simpleBootFront.option.window.location.href);
+                    // simpleBootFront.option.window.location.reload();
+                    // console.log('-3->', simpleBootFront.option.window.location.href);
+                    // this.simpleBootFrontQueue.enqueue(simpleBootFront);
+                    // await this.makeJsdom();
+                    // simpleBootFront.option.window.location.href = this.welcomUrl;
+                }
+                // console.log('----doen')
+                return false;
+            }
+            else {
+                // console.log('----doen2')
+                return true;
+            }
+        });
+    }
+    writeOkHtmlAndEnd({ rr, status = HttpStatus.Ok }, html) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // rr.res.writeHead(status, {[HttpHeaders.ContentType]: Mimes.TextHtml});
+            rr.resStatusCode(status);
+            rr.resSetHeader(HttpHeaders.ContentType, Mimes.TextHtml);
+            yield rr.resEnd(html);
+        });
+    }
+    proceedAfter({ rr, app }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // console.log('done--------', sw)
+            return true;
+        });
+    }
+}
+//# sourceMappingURL=SSRFilter.js.map

package/filters/SSRWorker.d.ts

@@ -0,0 +1,16 @@
+import { ConstructorType } from '@dooboostore/core/types';
+import { FactoryAndParams } from './SSRFilter';
+import JSDOM from 'jsdom';
+import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
+export declare class SSRWorker {
+    factory: FactoryAndParams;
+    otherInstanceSim?: Map<ConstructorType<any>, any>;
+    welcomUrl: string;
+    private simpleBootFront?;
+    constructor(factory: FactoryAndParams, otherInstanceSim?: Map<ConstructorType<any>, any>);
+    run(): Promise<void>;
+    makeJsdom(): Promise<JSDOM.JSDOM>;
+    makeFront(jsdom?: JSDOM.JSDOM): Promise<SimpleBootFront>;
+    getHtml(url: string): Promise<string>;
+}
+//# sourceMappingURL=SSRWorker.d.ts.map

package/filters/SSRWorker.js

@@ -0,0 +1,72 @@
+import { __awaiter } from "tslib";
+import { JsdomInitializer } from '../initializers/JsdomInitializer';
+import { RandomUtils } from '@dooboostore/core/random/RandomUtils';
+export class SSRWorker {
+    constructor(factory, otherInstanceSim) {
+        this.factory = factory;
+        this.otherInstanceSim = otherInstanceSim;
+        this.welcomUrl = 'http://localhost';
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.simpleBootFront = yield this.makeFront();
+        });
+    }
+    makeJsdom() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const jsdom = yield new JsdomInitializer(this.factory.frontDistPath, this.factory.frontDistIndexFileName || 'index.html', { url: this.welcomUrl }).run();
+            return jsdom;
+        });
+    }
+    makeFront(jsdom) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!jsdom) {
+                jsdom = yield this.makeJsdom();
+            }
+            const name = RandomUtils.uuid();
+            // const jsdom = await this.makeJsdom();
+            const window = jsdom.window;
+            window.ssrUse = false;
+            const option = this.factory.factorySimFrontOption(window);
+            // option.name = name;
+            const simpleBootFront = yield this.factory.factory.create(option, this.factory.using, this.factory.domExcludes);
+            simpleBootFront.run(this.otherInstanceSim);
+            simpleBootFront.jsdom = jsdom;
+            return simpleBootFront;
+        });
+    }
+    getHtml(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.simpleBootFront && this.simpleBootFront.option.window.ssrUse) {
+            }
+            else if (this.simpleBootFront) {
+                this.simpleBootFront.option.window.ssrUse = true;
+                delete this.simpleBootFront.option.window.server_side_data;
+                // run
+                yield this.simpleBootFront.goRouting(url);
+                let html = this.simpleBootFront.option.window.document.documentElement.outerHTML;
+                const serverSideData = this.simpleBootFront.option.window.server_side_data;
+                if (serverSideData) {
+                    const data = Object.entries(serverSideData).map(([k, v]) => {
+                        if (typeof v === 'string') {
+                            return `window.server_side_data.${k} = ${v}`;
+                        }
+                        else {
+                            return `window.server_side_data.${k} = ${JSON.stringify(v)}`;
+                        }
+                    }).join(';');
+                    if (data) {
+                        html = html.replace('</head>', `<script> window.server_side_data={}; ${data}; </script></head>`);
+                    }
+                }
+                this.makeFront().then(it => {
+                    this.simpleBootFront = it;
+                });
+                return html;
+            }
+            {
+            }
+        });
+    }
+}
+//# sourceMappingURL=SSRWorker.js.map

package/initializers/JsdomInitializer.d.ts

@@ -0,0 +1,11 @@
+import * as JSDOM from 'jsdom';
+import { ReconfigureSettings } from 'jsdom';
+export declare class JsdomInitializer {
+    private frontDistPath;
+    private frontDistIndexFileName;
+    private reconfigureSettings?;
+    constructor(frontDistPath: string, frontDistIndexFileName: string, reconfigureSettings?: ReconfigureSettings);
+    static loadFile(distPath: string, filePath: string): string;
+    run(): Promise<JSDOM.JSDOM>;
+}
+//# sourceMappingURL=JsdomInitializer.d.ts.map

package/initializers/JsdomInitializer.js

@@ -0,0 +1,63 @@
+import { __awaiter } from "tslib";
+import * as JSDOM from 'jsdom';
+import fs from 'fs';
+import path from 'path';
+export class JsdomInitializer {
+    constructor(frontDistPath, frontDistIndexFileName, reconfigureSettings) {
+        this.frontDistPath = frontDistPath;
+        this.frontDistIndexFileName = frontDistIndexFileName;
+        this.reconfigureSettings = reconfigureSettings;
+    }
+    static loadFile(distPath, filePath) {
+        return fs.readFileSync(path.join(distPath, filePath), 'utf8');
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // const indexHTML = fs.readFileSync(path.join(this.frontDistPath, 'index.html'), 'utf8');
+            // const indexHTML = JsdomInitializer.loadFile(this.frontDistPath, this.frontDistIndexFileName);
+            const pathStr = path.join(this.frontDistPath, this.frontDistIndexFileName);
+            const jsdom = yield JSDOM.JSDOM.fromFile(pathStr, {});
+            if (this.reconfigureSettings) {
+                jsdom.reconfigure(this.reconfigureSettings);
+            }
+            // devDependencies
+            // "@types/jsdom": "^21.1.2",
+            // "canvas": "^3.1.0",
+            // global setting
+            // @ts-ignore
+            global.document = jsdom.window.document;
+            // @ts-ignore
+            global.window = jsdom.window;
+            // @ts-ignore
+            global.window.requestAnimationFrame = () => { };
+            const dummyResponse = { ok: false, json: () => Promise.resolve({}) }; // as Response;
+            global.fetch = (...data) => Promise.resolve(dummyResponse);
+            // @ts-ignore
+            global.history = jsdom.window.history;
+            global.Event = jsdom.window.Event;
+            global.IntersectionObserver = jsdom.window.IntersectionObserver;
+            // @ts-ignore
+            // global.Error = ErrorBase;
+            // @ts-ignore
+            // global.navigator = jsdom.window.navigator;
+            global.NodeFilter = jsdom.window.NodeFilter;
+            global.Node = jsdom.window.Node;
+            global.HTMLElement = jsdom.window.HTMLElement;
+            global.HTMLMetaElement = jsdom.window.HTMLMetaElement;
+            global.Element = jsdom.window.Element;
+            global.HTMLCanvasElement = jsdom.window.HTMLCanvasElement;
+            global.HTMLCanvasElement.prototype.getContext = () => {
+                return null;
+            };
+            global.CanvasRenderingContext2D = jsdom.window.CanvasRenderingContext2D;
+            global.CanvasPattern = jsdom.window.CanvasPattern;
+            global.CanvasGradient = jsdom.window.CanvasGradient;
+            global.Path2D = jsdom.window.Path2D;
+            global.ImageData = jsdom.window.ImageData;
+            return jsdom;
+        });
+    }
+}
+//
+// export default new JsdomInitializer();
+//# sourceMappingURL=JsdomInitializer.js.map

package/option/HttpSSRServerOption.d.ts

@@ -0,0 +1,4 @@
+import { HttpServerOption } from '@dooboostore/simple-boot-http-server/option/HttpServerOption';
+export declare class HttpSSRServerOption extends HttpServerOption {
+}
+//# sourceMappingURL=HttpSSRServerOption.d.ts.map

package/option/HttpSSRServerOption.js

@@ -0,0 +1,4 @@
+import { HttpServerOption } from '@dooboostore/simple-boot-http-server/option/HttpServerOption';
+export class HttpSSRServerOption extends HttpServerOption {
+}
+//# sourceMappingURL=HttpSSRServerOption.js.map

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@dooboostore/simple-boot-http-server-ssr",
+  "version": "1.0.8",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "description": "front end SPA frameworks SSR",
+  "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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dooboostore-develop/packages"
+  },
+  "devDependencies": {
+    "@types/css": "^0.0.33",
+    "@types/jest": "^26.0.22",
+    "@types/jsdom": "^21.1.2",
+    "@types/mime-types": "^2.1.1",
+    "@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",
+    "supertest": "^6.1.3",
+    "ts-jest": "^26.5.4",
+    "@types/node": "^20",
+    "tslib": "^2.8.1",
+    "typescript": "^4.4.3"
+  },
+  "dependencies": {
+    "jsdom": "^26.0.0",
+    "reflect-metadata": "^0.2.2",
+    "@dooboostore/core-web": "1.0.1",
+    "@dooboostore/simple-boot": "1.0.43",
+    "@dooboostore/dom-render": "1.0.99",
+    "@dooboostore/simple-boot-front": "1.0.120",
+    "@dooboostore/core-node": "1.0.1",
+    "@dooboostore/core": "1.0.7",
+    "@dooboostore/simple-boot-http-server": "1.0.15"
+  },
+  "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-ssr-*.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:dev": "rm -rf ./dist && mkdir dist && cp package-dev.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  --sourceMap true --outDir dist --declarationDir dist",
+    "test": "jest --detectOpenHandles --forceExit",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/proxy/IntentSchemeFrontProxy.d.ts

@@ -0,0 +1,4 @@
+export declare class IntentSchemeFrontProxy implements ProxyHandler<any> {
+    get(target: any, prop: string): any;
+}
+//# sourceMappingURL=IntentSchemeFrontProxy.d.ts.map

package/proxy/IntentSchemeFrontProxy.js

@@ -0,0 +1,68 @@
+import { __awaiter, __decorate } from "tslib";
+import { getSim, Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
+import { HttpHeaders } from '@dooboostore/simple-boot-http-server/codes/HttpHeaders';
+import { HttpHeaders as SSRHttpHeaders } from '../codes/HttpHeaders';
+import { Mimes as SSRMimes } from '../codes/Mimes';
+import { ReflectUtils } from '@dooboostore/simple-boot/utils/reflect/ReflectUtils';
+import { ConvertUtils } from '@dooboostore/core/convert/ConvertUtils';
+let IntentSchemeFrontProxy = class IntentSchemeFrontProxy {
+    get(target, prop) {
+        const t = target[prop];
+        // TODO: 여기에 추가적인 프로퍼티 작성으 추가적으로 해야된다..
+        // if (typeof t === 'function') {
+        if (!['constructor', 'onProxyDomRender', 'toString'].includes(prop)) {
+            return (...args) => {
+                var _a, _b, _c;
+                // const simstanceManager = target._SimpleBoot_simstanceManager;
+                const simOption = target._SimpleBoot_simOption;
+                const config = getSim(target);
+                // const scheme = getSim(target)?.scheme;
+                const firstScheme = ConvertUtils.flatArray(config === null || config === void 0 ? void 0 : config.scheme)[0];
+                const key = firstScheme + '_' + prop;
+                const type = ReflectUtils.getReturnType(target, prop);
+                const isHas = (key in ((_a = simOption.window.server_side_data) !== null && _a !== void 0 ? _a : {}));
+                if (isHas) {
+                    const data = (_b = simOption.window.server_side_data) === null || _b === void 0 ? void 0 : _b[key];
+                    (_c = simOption.window.server_side_data) === null || _c === void 0 ? true : delete _c[key];
+                    let rdata;
+                    if (type instanceof Promise) {
+                        rdata = Promise.resolve(data);
+                    }
+                    else {
+                        rdata = data;
+                    }
+                    return rdata;
+                }
+                else {
+                    return fetch(`/${prop.toString()}`, {
+                        method: 'POST',
+                        headers: { [HttpHeaders.ContentType]: SSRMimes.ApplicationJsonPostSimpleBootSsrIntentScheme, [SSRHttpHeaders.XSimpleBootSsrIntentScheme]: firstScheme !== null && firstScheme !== void 0 ? firstScheme : '' },
+                        body: JSON.stringify(args[0])
+                    }).then((res) => __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            const data = yield res.json();
+                            return data;
+                        }
+                        catch (e) {
+                            try {
+                                return yield res.text();
+                            }
+                            catch (e) {
+                                return undefined;
+                            }
+                        }
+                    }));
+                }
+                // return t.apply(target, args);
+            };
+        }
+        else {
+            return t;
+        }
+    }
+};
+IntentSchemeFrontProxy = __decorate([
+    Sim
+], IntentSchemeFrontProxy);
+export { IntentSchemeFrontProxy };
+//# sourceMappingURL=IntentSchemeFrontProxy.js.map

package/proxy/IntentSchemeServerProxy.d.ts

@@ -0,0 +1,4 @@
+export declare class IntentSchemeServerProxy implements ProxyHandler<any> {
+    get(target: any, prop: string): any;
+}
+//# sourceMappingURL=IntentSchemeServerProxy.d.ts.map

package/proxy/IntentSchemeServerProxy.js

@@ -0,0 +1,39 @@
+import { __decorate } from "tslib";
+import { getSim, Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
+let IntentSchemeServerProxy = class IntentSchemeServerProxy {
+    get(target, prop) {
+        const t = target[prop];
+        if (typeof t === 'function') {
+            return (...args) => {
+                const simstanceManager = target._SimpleBoot_simstanceManager;
+                const simOption = target._SimpleBoot_simOption;
+                const config = getSim(target);
+                const data = t.apply(target, args);
+                if (simstanceManager && simOption && (config === null || config === void 0 ? void 0 : config.scheme) && simOption.window) {
+                    if (!simOption.window.server_side_data) {
+                        simOption.window.server_side_data = {};
+                    }
+                    const key = config.scheme + '_' + prop;
+                    if (data instanceof Promise) {
+                        data.then((it) => {
+                            simOption.window.server_side_data[key] = JSON.stringify(it);
+                            return it;
+                        });
+                    }
+                    else {
+                        simOption.window.server_side_data[key] = JSON.stringify(data);
+                    }
+                }
+                return data;
+            };
+        }
+        else {
+            return t;
+        }
+    }
+};
+IntentSchemeServerProxy = __decorate([
+    Sim
+], IntentSchemeServerProxy);
+export { IntentSchemeServerProxy };
+//# sourceMappingURL=IntentSchemeServerProxy.js.map

package/proxy/SymbolIntentApiServiceProxy.d.ts

@@ -0,0 +1,15 @@
+import { ApiService } from '@dooboostore/simple-boot/fetch/ApiService';
+export type Config<T = any> = {
+    multipartFormData?: boolean;
+    bypassTransform?: boolean;
+    transformText?: boolean;
+    headers?: HeadersInit;
+    body?: T;
+};
+export declare class SymbolIntentApiServiceProxy<T extends object> implements ProxyHandler<T> {
+    private apiService;
+    constructor(apiService: ApiService);
+    get(target: T, prop: string | symbol, receiver: any): any;
+    apply(target: T, thisArg: any, argArray: any[]): any;
+}
+//# sourceMappingURL=SymbolIntentApiServiceProxy.d.ts.map

package/proxy/SymbolIntentApiServiceProxy.js

@@ -0,0 +1,67 @@
+import { __decorate, __metadata } from "tslib";
+import { getSim, Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
+import { makeIntentHeaderBySymbol } from '../codes/HttpHeaders';
+import { ConvertUtils } from '@dooboostore/core/convert/ConvertUtils';
+import { ApiService } from '@dooboostore/simple-boot/fetch/ApiService';
+let SymbolIntentApiServiceProxy = class SymbolIntentApiServiceProxy {
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    get(target, prop, receiver) {
+        const simConfig = getSim(target);
+        const apiService = this.apiService;
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === 'function' && (simConfig === null || simConfig === void 0 ? void 0 : simConfig.symbol)) {
+            return function (...args) {
+                const f = value;
+                const p = (userConfig) => {
+                    var _a;
+                    const headers = Object.assign(Object.assign({}, ((_a = userConfig === null || userConfig === void 0 ? void 0 : userConfig.headers) !== null && _a !== void 0 ? _a : {})), makeIntentHeaderBySymbol(simConfig.symbol));
+                    if (userConfig === null || userConfig === void 0 ? void 0 : userConfig.multipartFormData) {
+                        return apiService.post({
+                            target: `/${String(prop)}`,
+                            config: {
+                                bypassTransform: userConfig === null || userConfig === void 0 ? void 0 : userConfig.bypassTransform,
+                                transformText: userConfig === null || userConfig === void 0 ? void 0 : userConfig.transformText,
+                                fetch: {
+                                    credentials: 'include',
+                                    headers: headers,
+                                    body: ConvertUtils.toFormData(userConfig === null || userConfig === void 0 ? void 0 : userConfig.body)
+                                }
+                            }
+                        });
+                    }
+                    else {
+                        return apiService.postJson({
+                            target: `/${String(prop)}`,
+                            config: {
+                                bypassTransform: userConfig === null || userConfig === void 0 ? void 0 : userConfig.bypassTransform,
+                                transformText: userConfig === null || userConfig === void 0 ? void 0 : userConfig.transformText,
+                                fetch: {
+                                    credentials: 'include',
+                                    headers: headers,
+                                    body: userConfig === null || userConfig === void 0 ? void 0 : userConfig.body
+                                }
+                            }
+                        });
+                    }
+                };
+                args.push(p);
+                return Reflect.apply(f, target, args);
+                // return f.apply(target, args);
+            };
+        }
+        return Reflect.get(target, prop, receiver);
+    }
+    apply(target, thisArg, argArray) {
+        console.log('SymbolIntentApiServiceProxy apply');
+        // @ts-ignore
+        return Reflect.apply(target, thisArg, argArray);
+    }
+};
+SymbolIntentApiServiceProxy = __decorate([
+    Sim,
+    __metadata("design:paramtypes", [ApiService])
+], SymbolIntentApiServiceProxy);
+export { SymbolIntentApiServiceProxy };
+//# sourceMappingURL=SymbolIntentApiServiceProxy.js.map