simple-boot-http-server-ssr

import 'reflect-metadata';
import { SimpleBootHttpSSRServer } from '@dooboostore/simple-boot-http-server-ssr/SimpleBootHttpSSRServer';
import { HttpSSRServerOption } from '@dooboostore/simple-boot-http-server-ssr/option/HttpSSRServerOption';
import { SSRFilter } from '@dooboostore/simple-boot-http-server-ssr/filters/SSRFilter';
import { IntentSchemeFilter } from '@dooboostore/simple-boot-http-server-ssr/filters/IntentSchemeFilter';
import { SimpleBootHttpSSRFactory } from '@dooboostore/simple-boot-http-server-ssr/SimpleBootHttpSSRFactory';
import Factory, { MakeSimFrontOption } from './bootfactory';
import { RootRouter } from './root.router';
import { GlobalAdvice } from './advices/GlobalAdvice';

// SSR configuration
const ssrOption = {
  frontDistPath: './dist-front-end',
  frontDistIndexFileName: 'index.html',
  factorySimFrontOption: (window: any) => MakeSimFrontOption(window),
  factory: Factory as SimpleBootHttpSSRFactory,
  using: [/* services */],
  ssrExcludeFilter: (rr) => /^\/api\//.test(rr.reqUrl),
  poolOption: {
    max: 50,
    min: 5
  }
};

const ssrFilter = new SSRFilter(ssrOption);

const option = new HttpSSRServerOption(
  {
    listen: { port: 8080 },
    globalAdvice: new GlobalAdvice(),
    filters: [ssrFilter, IntentSchemeFilter]
  },
  {
    rootRouter: RootRouter
  }
);

const ssr = new SimpleBootHttpSSRServer(option);
await ssr.run();

console.log('🚀 SSR Server running on http://localhost:8080');

import { SimFrontOption, UrlType } from '@dooboostore/simple-boot-front/option/SimFrontOption';
import { SimpleBootHttpSSRFactory } from '@dooboostore/simple-boot-http-server-ssr/SimpleBootHttpSSRFactory';
import { ConstructorType, isDefined } from '@dooboostore/core/types';
import { SimpleBootFront } from '@dooboostore/simple-boot-front/SimpleBootFront';
import { IndexRouterComponent } from './pages/index.router.component';
import { Observable, Subject, Subscription } from 'rxjs';
import { AlertService } from '@dooboostore/simple-boot/alert/AlertService';
import { ApiService } from '@dooboostore/simple-boot/fetch/ApiService';

export const MakeSimFrontOption = (window: any): SimFrontOption => {
  return new SimFrontOption(
    { window, urlType: UrlType.path, using: [ApiService] },
    { rootRouter: IndexRouterComponent }
  );
};

class Factory extends SimpleBootHttpSSRFactory {
  async factory(
    simFrontOption: SimFrontOption,
    using: (ConstructorType<any> | Function)[],
    domExcludes: ConstructorType<any>[]
  ) {
    simFrontOption.using ??= [];
    
    if (Array.isArray(simFrontOption.using)) {
      simFrontOption.using.push(...using);
    } else {
      simFrontOption.using = [simFrontOption.using, using].filter(isDefined);
    }

    const simpleBootFront = new SimpleBootFront(simFrontOption);
    
    // Exclude from proxy
    simpleBootFront.domRendoerExcludeProxy.push(
      Subject,
      Observable,
      Subscription,
      AlertService,
      ApiService,
      ...domExcludes
    );
    
    return simpleBootFront;
  }
}

export default new Factory();

import { RequestResponse } from '@dooboostore/simple-boot-http-server/models/RequestResponse';
import { Config } from '@dooboostore/simple-boot-http-server-ssr/proxy/SymbolIntentApiServiceProxy';

export namespace TalkService {
  export const SYMBOL = Symbol.for('TalkService');
  export type TalkRequest = { seq: number };
  export type TalkResponse = { name: string; content: string };
}

export interface TalkService {
  talk(
    request: TalkService.TalkRequest,
    data?: RequestResponse | ((config: Config<TalkService.TalkRequest>) => Promise<TalkService.TalkResponse>)
  ): Promise<TalkService.TalkResponse>;
}

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { RequestResponse } from '@dooboostore/simple-boot-http-server/models/RequestResponse';
import { TalkService } from './TalkService';

@Sim({ symbol: TalkService.SYMBOL })
export class BackTalkService implements TalkService {
  async talk(
    request: TalkService.TalkRequest,
    rr?: RequestResponse
  ): Promise<TalkService.TalkResponse> {
    // Server-side implementation
    return {
      name: 'hello intent api',
      content: new Date().toISOString()
    };
  }
}

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { SymbolIntentApiServiceProxy } from '@dooboostore/simple-boot-http-server-ssr/proxy/SymbolIntentApiServiceProxy';
import { TalkService } from './TalkService';

@Sim({
  symbol: TalkService.SYMBOL,
  proxy: SymbolIntentApiServiceProxy
})
export class FrontTalkService implements TalkService {
  async talk(
    request: TalkService.TalkRequest,
    data?: ((config: Config<TalkService.TalkRequest>) => Promise<TalkService.TalkResponse>)
  ): Promise<TalkService.TalkResponse> {
    // Calls server via intent scheme
    return data!({ body: request });
  }
}

import { Sim, Lifecycle } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { Component } from '@dooboostore/simple-boot-front/decorators/Component';
import { ComponentBase } from '@dooboostore/dom-render/components/ComponentBase';
import { Inject } from '@dooboostore/simple-boot/decorators/inject/Inject';
import { TalkService } from './service/TalkService';

@Sim({ scope: Lifecycle.Transient })
@Component({
  template: `
    <div class="page">
      <h1>Talk Service Demo</h1>
      <button dr-event-click="@this@.apiIntentFetch()">
        Call Service
      </button>
      <div>${@this@.result$}</div>
    </div>
  `,
  styles: []
})
export class IndexRouteComponent extends ComponentBase<any> {
  public result = '';

  constructor(
    @Inject({ symbol: TalkService.SYMBOL }) private talkService: TalkService
  ) {
    super();
  }

  async apiIntentFetch() {
    // Works on both server and client!
    const data = await this.talkService.talk({ seq: Math.random() });
    this.result = JSON.stringify(data);
  }
}

import { SimpleBootHttpSSRServer } from '@dooboostore/simple-boot-http-server-ssr/SimpleBootHttpSSRServer';
import { HttpSSRServerOption } from '@dooboostore/simple-boot-http-server-ssr/option/HttpSSRServerOption';
import { IntentSchemeFilter } from '@dooboostore/simple-boot-http-server-ssr/filters/IntentSchemeFilter';
import { BackTalkService } from './services/BackTalkService';

const option = new HttpSSRServerOption(
  {
    listen: { port: 8080 },
    filters: [
      IntentSchemeFilter  // Enable intent scheme
    ]
  },
  {
    rootRouter: RootRouter
  }
);

const server = new SimpleBootHttpSSRServer(option);
await server.run();

// IntentSchemeFilter automatically:
// 1. Intercepts requests with X-Simple-Boot-Ssr-Intent-Scheme header
// 2. Extracts Symbol from header
// 3. Publishes Intent to IntentManager
// 4. Routes to appropriate service method
// 5. Returns JSON response

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { SaveAroundAfter } from '@dooboostore/simple-boot-http-server-ssr/decorators/SaveAroundAfter';

@Sim({ symbol: TalkService.SYMBOL })
export class BackTalkService implements TalkService {
  async talk(request: TalkService.TalkRequest): Promise<TalkService.TalkResponse> {
    const result = {
      name: 'hello intent api',
      content: new Date().toISOString()
    };
    
    // Save for client hydration
    SaveAroundAfter(this, 'talk', [request], result);
    
    return result;
  }
}

// Saved data is automatically:
// 1. JSON.stringify(result)
// 2. Stored in window.server_side_data
// 3. Injected into HTML before sending to client

import { Sim } from '@dooboostore/simple-boot/decorators/SimDecorator';
import { LoadAroundBefore } from '@dooboostore/simple-boot-http-server-ssr/decorators/LoadAroundBefore';

@Sim({ symbol: TalkService.SYMBOL, proxy: SymbolIntentApiServiceProxy })
export class FrontTalkService implements TalkService {
  async talk(request: TalkService.TalkRequest, data?: any): Promise<TalkService.TalkResponse> {
    // Try to load from hydrated data first
    try {
      LoadAroundBefore(this, 'talk', [request]);
    } catch (e) {
      // If data found, it throws AroundForceReturn
      // which returns the cached data immediately
      if (e instanceof AroundForceReturn) {
        return e.returnValue;
      }
    }
    
    // No cached data, make actual API call
    return data!({ body: request });
  }
}

// LoadAroundBefore automatically:
// 1. Checks window.server_side_data for cached result
// 2. If found, throws AroundForceReturn with data
// 3. Deletes data from window.server_side_data
// 4. If not found, allows normal execution

import { JsdomInitializer } from '@dooboostore/simple-boot-http-server-ssr/initializers/JsdomInitializer';

const initializer = new JsdomInitializer(
  './dist-front-end',
  'index.html',
  { url: 'http://localhost' }
);

const jsdom = await initializer.run();

// JsdomInitializer automatically sets up:
// - global.document
// - global.window
// - global.history
// - global.Event
// - global.HTMLElement
// - global.Node
// - global.IntersectionObserver
// - And many more browser APIs

const window = jsdom.window as unknown as Window & typeof globalThis;

import { SSRFilter } from '@dooboostore/simple-boot-http-server-ssr/filters/SSRFilter';

const ssrFilter = new SSRFilter({
  frontDistPath: './dist-front-end',
  frontDistIndexFileName: 'index.html',
  factorySimFrontOption: (window: any) => MakeSimFrontOption(window),
  factory: Factory,
  using: [BackTalkService],
  
  // Pool configuration
  poolOption: {
    max: 50,                      // Maximum pool size
    min: 5,                       // Minimum pool size
    clearIntervalTime: 300000     // Clear every 5 minutes
  },
  
  // Exclude API routes from SSR
  ssrExcludeFilter: (rr) => /^\/api\//.test(rr.reqUrl),
  
  // Enable 404 error handling
  simpleBootFront: {
    notFoundError: true
  }
});

// Pool automatically:
// 1. Pre-creates 'min' instances on startup
// 2. Creates more instances on demand up to 'max'
// 3. Recycles instances after each request
// 4. Clears old instances based on generation
// 5. Manages queue for available instances

import 'reflect-metadata';
import { SimpleBootHttpSSRServer } from '@dooboostore/simple-boot-http-server-ssr/SimpleBootHttpSSRServer';
import { HttpSSRServerOption } from '@dooboostore/simple-boot-http-server-ssr/option/HttpSSRServerOption';
import { SSRFilter } from '@dooboostore/simple-boot-http-server-ssr/filters/SSRFilter';
import { IntentSchemeFilter } from '@dooboostore/simple-boot-http-server-ssr/filters/IntentSchemeFilter';
import { ResourceFilter } from '@dooboostore/simple-boot-http-server/filters/ResourceFilter';
import { NotFoundError } from '@dooboostore/simple-boot-http-server/errors/NotFoundError';
import Factory, { MakeSimFrontOption } from './bootfactory';
import { RootRouter } from './root.router';
import { BackTalkService } from './services/BackTalkService';
import { GlobalAdvice } from './advices/GlobalAdvice';
import { CloseLogEndPoint } from './endpoints/CloseLogEndPoint';

class Server {
  async run() {
    // SSR Filter configuration
    const ssrOption = {
      frontDistPath: './dist-front-end',
      frontDistIndexFileName: 'index.html',
      factorySimFrontOption: (window: any) => MakeSimFrontOption(window),
      factory: Factory,
      using: [BackTalkService],
      ssrExcludeFilter: (rr) => /^\/api\//.test(rr.reqUrl),
      poolOption: {
        max: 50,
        min: 5
      },
      simpleBootFront: {
        notFoundError: true
      }
    };

    // Resource filter for static files
    const resourceFilter = new ResourceFilter(
      './dist-front-end',
      ['assets/.*', '\\.js$', '\\.map$', '\\.ico$', '\\.png$']
    );

    const ssrFilter = new SSRFilter(ssrOption);

    // Server configuration
    const option = new HttpSSRServerOption(
      {
        listen: { port: 8080, hostname: '0.0.0.0' },
        globalAdvice: new GlobalAdvice(),
        closeEndPoints: [new CloseLogEndPoint()],
        noSuchRouteEndPointMappingThrow: () => new NotFoundError(),
        filters: [
          resourceFilter,
          ssrFilter,
          IntentSchemeFilter
        ]
      },
      {
        rootRouter: RootRouter
      }
    );

    const ssr = new SimpleBootHttpSSRServer(option);
    await ssr.run();
    
    console.log('🚀 SSR Server running on http://localhost:8080');
    return ssr;
  }
}

new Server().run().then(() => {
  console.log('✅ Server started successfully!');
});