@Slf4j
@SpringBootApplication
@EnableAspectJAutoProxy
@EnableScheduling
@ServletComponentScan
public class OnlydreamApplication implements CommandLineRunner, ApplicationRunner {

	public static void main(String[] args) {
		ApiContextInitializer.init();
		SpringApplication.run(OnlydreamApplication.class, args);
	}


	@Override
	public void run(String... args) throws Exception {

	}

	@Override
	public void run(ApplicationArguments args) throws Exception {

	}
}

async function bootstrap() {
   const app = await NestFactory.create(AppModule, {... });
   await app.listen(9911, "0.0.0.0");
}

bootstrap();

//node_modules/next/dist/cli/next-start.js

#!/usr/bin/env node
'use strict'
Object.defineProperty(exports, '__esModule', {
  value: true,
})
exports.nextStart = void 0
var _indexJs = _interopRequireDefault(
  require('next/dist/compiled/arg/index.js')
)
var _startServer = require('../server/lib/start-server')
var _utils = require('../server/lib/utils')
var Log = _interopRequireWildcard(require('../build/output/log'))
var _isError = _interopRequireDefault(require('../lib/is-error'))
var _getProjectDir = require('../lib/get-project-dir')
function _interopRequireDefault(obj) {
  return obj && obj.__esModule
    ? obj
    : {
        default: obj,
      }
}
//기타 엄청난 코드들...

//node_modules/next/dist/cli/next-start.js

const nextStart = argv => {
  const validArgs = {
    // Types
    '--help': Boolean,
    '--port': Number,
    '--hostname': String,
    '--keepAliveTimeout': Number,
    // Aliases
    '-h': '--help',
    '-p': '--port',
    '-H': '--hostname',
  }
}
//...
;(0, _startServer)
  .startServer({
    dir,
    hostname: host,
    port,
    keepAliveTimeout,
  })
  .then(async app => {
    const appUrl = `http://${app.hostname}:${app.port}`
    Log.ready(`started server on ${host}:${app.port}, url: ${appUrl}`)
    await app.prepare()
  })
  .catch(err => {
    console.error(err)
    process.exit(1)
  })

//node_modules/next/dist/server/start-server.d.ts

import type { NextServerOptions, NextServer } from '../next';
interface StartServerOptions extends NextServerOptions {
    allowRetry?: boolean;
    keepAliveTimeout?: number;
}
export declare function startServer(opts: StartServerOptions): Promise<NextServer>;
export {};

//node_modules/next/dist/server/lib/start-server.js

'use strict'
Object.defineProperty(exports, '__esModule', {
  value: true,
})
exports.startServer = startServer
var _log = require('../../build/output/log')
var _http = _interopRequireDefault(require('http'))
var _next = _interopRequireDefault(require('../next'))
function _interopRequireDefault(obj) {
  return obj && obj.__esModule
    ? obj
    : {
        default: obj,
      }
}
function startServer(opts) {
  let requestHandler
  const server = _http.default.createServer((req, res) => {
    return requestHandler(req, res)
  })
  //...
}

//node_modules/next/dist/server/lib/start-server.js

server.on('listening', () => {
  const addr = server.address()
  const hostname =
    !opts.hostname || opts.hostname === '0.0.0.0' ? 'localhost' : opts.hostname
  const app = (0, _next).default({
    ...opts,
    hostname,
    customServer: false,
    httpServer: server,
    port: addr && typeof addr === 'object' ? addr.port : port,
  })
  requestHandler = app.getRequestHandler()
  upgradeHandler = app.getUpgradeHandler()
  resolve(app)
})
server.listen(port, opts.hostname)

//node_modules/next/dist/server/next.d.ts

//...

export declare class NextServer {
  private serverPromise?
  private server?
  private reqHandlerPromise?
  private preparedAssetPrefix?
  options: NextServerOptions
  constructor(options: NextServerOptions)
  get hostname(): string | undefined
  get port(): number | undefined
  getRequestHandler(): RequestHandler
  getUpgradeHandler(): (
    req: IncomingMessage,
    socket: any,
    head: any
  ) => Promise<void>
  setAssetPrefix(assetPrefix: string): void
  logError(...args: Parameters<Server['logError']>): void
  render(...args: Parameters<Server['render']>): Promise<void>
  renderToHTML(
    ...args: Parameters<Server['renderToHTML']>
  ): Promise<string | null>
  renderError(...args: Parameters<Server['renderError']>): Promise<void>
  renderErrorToHTML(
    ...args: Parameters<Server['renderErrorToHTML']>
  ): Promise<string | null>
  render404(...args: Parameters<Server['render404']>): Promise<void>
  serveStatic(...args: Parameters<Server['serveStatic']>): Promise<void>
  prepare(): Promise<void>
  close(): Promise<any>
  private createServer
  private loadConfig
  private getServer
  private getServerRequestHandler
}

//node_modules/next/dist/server/next.js

async render(...args) {
        const server = await this.getServer();
        return server.render(...args);
    }
    async renderToHTML(...args) {
        const server = await this.getServer();
        return server.renderToHTML(...args);
    }
    async renderError(...args) {
        const server = await this.getServer();
        return server.renderError(...args);
    }
    async renderErrorToHTML(...args) {
        const server = await this.getServer();
        return server.renderErrorToHTML(...args);
    }
    async render404(...args) {
        const server = await this.getServer();
        return server.render404(...args);
    }

async getServer() {
        if (!this.serverPromise) {
            setTimeout(getServerImpl, 10);
            this.serverPromise = this.loadConfig().then(async (conf)=>{
                this.server = await this.createServer({
                    ...this.options,
                    conf
                });
                if (this.preparedAssetPrefix) {
                    this.server.setAssetPrefix(this.preparedAssetPrefix);
                }
                return this.server;
            });
        }
        return this.serverPromise;
    }

//node_modules/next/dist/server/next.js

async createServer(options) {
        if (options.dev) {
            const DevServer = require("./dev/next-dev-server").default;
            return new DevServer(options);
        }
        const ServerImplementation = await getServerImpl();
        return new ServerImplementation(options);
    }

//
//node_modules/next/dist/server/dev/next-dev-server.d.ts

export interface Options extends ServerOptions {
  /**
   * Tells of Next.js is running from the `next dev` command
   */
  isNextDevCommand?: boolean
}
export default class DevServer extends Server {
  ///....
  protected getAppPathsManifest(): undefined
  protected getCustomRoutes(): CustomRoutes
  protected getPreviewProps(): __ApiPreviewProps
  protected getPagesManifest(): undefined
  protected getAppPathsManifest(): undefined
  protected getMiddleware(): MiddlewareRoutingItem | undefined
  protected getEdgeFunctions(): RoutingItem[]
  protected getServerComponentManifest(): undefined
  protected getServerCSSManifest(): undefined
  protected hasMiddleware(): Promise<boolean>
  protected ensureMiddleware(): Promise<void>
  protected ensureEdgeFunction({
    page,
    appPaths,
  }: {
    page: string
    appPaths: string[] | null
  }): Promise<void>
  generateRoutes(): {
    headers: import('../router').Route[]
    rewrites: {
      beforeFiles: import('../router').Route[]
      afterFiles: import('../router').Route[]
      fallback: import('../router').Route[]
    }
    redirects: import('../router').Route[]
    catchAllRoute: import('../router').Route
    catchAllMiddleware: import('../router').Route[]
    pageChecker: import('../router').PageChecker
    useFileSystemPublicRoutes: boolean
    dynamicRoutes: import('../router').DynamicRoutes | undefined
    nextConfig: import('../config-shared').NextConfig
    fsRoutes: import('../router').Route[]
  }
  protected generatePublicRoutes(): never[]
  protected getDynamicRoutes(): never[]
  protected findPageComponents({
    pathname,
    query,
    params,
    isAppPath,
    appPaths,
  }: {
    pathname: string
    query: ParsedUrlQuery
    params: Params
    isAppPath: boolean
    appPaths?: string[] | null
  }): Promise<FindComponentsResult | null>
}

//node_modules/next/dist/server/dev/next-dev-server.js

 async run(req, res, parsedUrl) {
        await this.devReady;
        this.setupWebSocketHandler(undefined, req);
        const { basePath  } = this.nextConfig;
        let originalPathname = null;
        if (basePath && (0, _pathHasPrefix).pathHasPrefix(parsedUrl.pathname || "/", basePath)) {
            // strip basePath before handling dev bundles
            // If replace ends up replacing the full url it'll be `undefined`, meaning we have to default it to `/`
            originalPathname = parsedUrl.pathname;
            parsedUrl.pathname = (0, _removePathPrefix).removePathPrefix(parsedUrl.pathname || "/", basePath);
        }
        const { pathname  } = parsedUrl;
        if (pathname.startsWith("/_next")) {
            if (await (0, _fileExists).fileExists((0, _path).join(this.publicDir, "_next"))) {
                throw new Error(_constants.PUBLIC_DIR_MIDDLEWARE_CONFLICT);
            }
        }
        const { finished =false  } = await this.hotReloader.run(req.originalRequest, res.originalResponse, parsedUrl);
        if (finished) {
            return;
        }
        if (originalPathname) {
            // restore the path before continuing so that custom-routes can accurately determine
            // if they should match against the basePath or not
            parsedUrl.pathname = originalPathname;
        }
        try {
            return await super.run(req, res, parsedUrl);
        } catch (error) {
            res.statusCode = 500;
            const err = (0, _isError).getProperError(error);
            try {
                this.logErrorWithOriginalStack(err).catch(()=>{});
                return await this.renderError(err, req, res, pathname, {
                    __NEXT_PAGE: (0, _isError).default(err) && err.page || pathname || ""
                });
            } catch (internalErr) {
                console.error(internalErr);
                res.body("Internal Server Error").send();
            }
        }
    }

//var _nextServer = _interopRequireWildcard(require("../next-server"));

class DevServer extends _nextServer.default {}

//node_modules/next/dist/server/next.js

const getServerImpl = async () => {
  if (ServerImpl === undefined)
    ServerImpl = (await Promise.resolve(require('./next-server'))).default
  return ServerImpl
}

export default class NextNodeServer extends BaseServer {}

//node_modules/next/dist/server/base-server.js

async renderToResponse(ctx) {
        const { res , query , pathname  } = ctx;
        let page = pathname;
        const bubbleNoFallback = !!query._nextBubbleNoFallback;
        delete query._nextBubbleNoFallback;
        try {
            // Ensure a request to the URL /accounts/[id] will be treated as a dynamic
            // route correctly and not loaded immediately without parsing params.
            if (!(0, _utils1).isDynamicRoute(page)) {
                const result = await this.renderPageComponent(ctx, bubbleNoFallback);
                if (result !== false) return result;
            }
            if (this.dynamicRoutes) {
                for (const dynamicRoute of this.dynamicRoutes){
                    const params = dynamicRoute.match(pathname);
                    if (!params) {
                        continue;
                    }
                    page = dynamicRoute.page;
                    const result = await this.renderPageComponent({
                        ...ctx,
                        pathname: page,
                        renderOpts: {
                            ...ctx.renderOpts,
                            params
                        }
                    }, bubbleNoFallback);
                    if (result !== false) return result;
                }
            }
            // currently edge functions aren't receiving the x-matched-path
            // header so we need to fallback to matching the current page
            // when we weren't able to match via dynamic route to handle
            // the rewrite case
            // @ts-expect-error extended in child class web-server
            if (this.serverOptions.webServerConfig) {
                // @ts-expect-error extended in child class web-server
                ctx.pathname = this.serverOptions.webServerConfig.page;
                const result = await this.renderPageComponent(ctx, bubbleNoFallback);
                if (result !== false) return result;
            }
        } catch (error) {
            const err = (0, _isError).getProperError(error);
            if (error instanceof _utils.MissingStaticPage) {
                console.error("Invariant: failed to load static page", JSON.stringify({
                    page,
                    url: ctx.req.url,
                    matchedPath: ctx.req.headers["x-matched-path"],
                    initUrl: (0, _requestMeta).getRequestMeta(ctx.req, "__NEXT_INIT_URL"),
                    didRewrite: (0, _requestMeta).getRequestMeta(ctx.req, "_nextDidRewrite"),
                    rewroteUrl: (0, _requestMeta).getRequestMeta(ctx.req, "_nextRewroteUrl")
                }, null, 2));
                throw err;
            }
            if (err instanceof NoFallbackError && bubbleNoFallback) {
                throw err;
            }
            if (err instanceof _utils.DecodeError || err instanceof _utils.NormalizeError) {
                res.statusCode = 400;
                return await this.renderErrorToResponse(ctx, err);
            }
            res.statusCode = 500;
            // if pages/500 is present we still need to trigger
            // /_error `getInitialProps` to allow reporting error
            if (await this.hasPage("/500")) {
                ctx.query.__nextCustomErrorRender = "1";
                await this.renderErrorToResponse(ctx, err);
                delete ctx.query.__nextCustomErrorRender;
            }
            const isWrappedError = err instanceof WrappedBuildError;
            if (!isWrappedError) {
                if (this.minimalMode && process.env.NEXT_RUNTIME !== "edge" || this.renderOpts.dev) {
                    if ((0, _isError).default(err)) err.page = page;
                    throw err;
                }
                this.logError((0, _isError).getProperError(err));
            }
            const response = await this.renderErrorToResponse(ctx, isWrappedError ? err.innerError : err);
            return response;
        }
        if (this.router.catchAllMiddleware[0] && !!ctx.req.headers["x-nextjs-data"] && (!res.statusCode || res.statusCode === 200 || res.statusCode === 404)) {
            res.setHeader("x-nextjs-matched-path", `${query.__nextLocale ? `/${query.__nextLocale}` : ""}${pathname}`);
            res.statusCode = 200;
            res.setHeader("content-type", "application/json");
            res.body("{}");
            res.send();
            return null;
        }
        res.statusCode = 404;
        return this.renderErrorToResponse(ctx, null);
    }