@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/src/http/api/api-server.ts

@@ -0,0 +1,130 @@
+import { generateUuidV4 } from "#Source/identifier/uuid.ts"
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/logger.ts"
+import { Logger } from "#Source/log/logger.ts"
+import { toQueryObject } from "#Source/route/index.ts"
+
+import type { AnyApiHost, ApiHostStartResult } from "./api-host.ts"
+import type { AnyApi } from "./api.ts"
+
+export interface ApiServerOptions extends LoggerFriendlyOptions {
+  apiList: AnyApi[]
+  apiHost: AnyApiHost
+}
+/**
+ * {@link ApiServer} 包含若干个 {@link Api}（接口），并且需要指定一个监听端口（Port）。Server 启动
+ * 后会监听对应的端口，将端口接收到的请求分发给不同的接口。
+ *
+ * 请求 -> Server -> Api
+ *
+ * 具体来说，当服务器收到请求时：
+ * - 通过请求的路径（path）和方法（method）与所有的 {@link Api} 进行匹配。
+ *   - 如果能匹配到，将请求分给第一个匹配到的接口。
+ *   - 如果匹配不到任何接口，将返回 404。
+ * - 按照 {@link Api} 的处理逻辑进行处理，最终将结果返回给请求方。
+ */
+export class ApiServer implements LoggerFriendly {
+  readonly options: ApiServerOptions
+
+  readonly logger: Logger
+
+  constructor(options: ApiServerOptions) {
+    this.options = options
+
+    this.logger = Logger.fromOptions(options).setDefaultName("ApiServer")
+
+    this.initialize()
+  }
+
+  protected initialize(): void {
+    const { apiList, apiHost } = this.options
+
+    apiHost.attachApiCoreHandler(async (apiCore) => {
+      const path = await apiCore.getRequestPath()
+      const method = (await apiCore.getRequestMethod()).toUpperCase()
+
+      // tag every request with a unique identifier for better logging
+      const logger = Logger
+        .derive(this.logger)
+        .setDefaultName(`${method} ${path} ${generateUuidV4()}`)
+
+      try {
+        logger.log(`start handling request`)
+
+        logger.log(`start finding target api`)
+        // 根据请求的路径和方法找到对应的接口
+        const targetApi = apiList.find((api) => {
+          const apiSchema = api.getApiSchema()
+          const apiSchemaPath = apiSchema.getPath()
+          const apiSchemaMethod = apiSchema.getMethod().toUpperCase()
+          return apiSchemaPath === path && apiSchemaMethod === method
+        })
+
+        // 如果找不到对应的接口，抛出错误
+        if (targetApi === undefined) {
+          logger.error(`finding target api failed`)
+          throw new Error(`finding target api failed`)
+        }
+        else {
+          logger.log(`finding target api success`)
+        }
+
+        // 如果找到对应的接口，获取接口定义，按照接口的定义进行处理
+        const apiSchema = targetApi.getApiSchema()
+
+        // 1. 准备 ApiHandlerContext
+        logger.log(`start preparing api handler context`)
+        const inputSearch = await apiCore.getRequestSearch()
+        const inputQueryObject = toQueryObject(inputSearch)
+        const inputQuerySchema = apiSchema.getInputQuerySchema()
+        const validateResultQuery = await inputQuerySchema["~standard"].validate(inputQueryObject)
+        if (validateResultQuery.issues !== undefined) {
+          logger.error(`validating api input query failed, issues: ${JSON.stringify(validateResultQuery.issues)}`)
+          throw new Error(`validating api input query failed, issues: ${JSON.stringify(validateResultQuery.issues)}`)
+        }
+        const inputQuery = validateResultQuery.value
+
+        const inputBodySchema = apiSchema.getInputBodySchema()
+        const inputBodyJson = await apiCore.getRequestBodyJson()
+        const validateResult = await inputBodySchema["~standard"].validate(inputBodyJson)
+        if (validateResult.issues !== undefined) {
+          logger.error(`validating api input body failed, issues: ${JSON.stringify(validateResult.issues)}`)
+          throw new Error(`validating api input body failed, issues: ${JSON.stringify(validateResult.issues)}`)
+        }
+        const inputBody = validateResult.value
+        logger.log(`preparing api handler context success`)
+
+        // 2. 执行 ApiHandler
+        logger.log(`start executing api handler`)
+        const apiHandler = targetApi.getApiHandler()
+        const apiResult = await apiHandler({
+          ...apiSchema.getApiSchemaOptions(),
+          inputQuery,
+          inputBody,
+          apiCore,
+          logger,
+        })
+        logger.log(`executing api handler success`)
+
+        // 3. 处理 ApiHandler 的执行结果，这一步会将数据返回给请求方
+        logger.log(`start handling api result`)
+        await apiResult.handle(apiCore)
+        logger.log(`handling api result success`)
+
+        logger.log(`handling request success`)
+      } catch (exception) {
+        logger.error(`handling request failed, exception: ${String(exception)}`)
+        await apiCore.error()
+      }
+    })
+  }
+
+  async start(): Promise<ApiHostStartResult> {
+    const { apiHost } = this.options
+    const result = await apiHost.start()
+    return result
+  }
+}
+
+export const createApiServer = (options: ApiServerOptions): ApiServer => {
+  return new ApiServer(options)
+}

package/src/http/api/api-test.ts

@@ -0,0 +1,142 @@
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import { Logger } from "#Source/log/index.ts"
+
+import type { AnyApiSchema } from "./api-schema.ts"
+
+export interface BeforeApiTestHandlerContext<
+  ApiSchema extends AnyApiSchema,
+> {
+  apiSchema: ApiSchema
+}
+export type BeforeApiTestHandler<
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+> = (context: BeforeApiTestHandlerContext<ApiSchema>) => Promise<BeforeApiTestResult>
+export interface ApiTestHandlerContext<
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestHandlerResult,
+> {
+  apiSchema: ApiSchema
+  beforeApiTestResult: BeforeApiTestHandlerResult
+}
+export type ApiTestHandler<
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+  ApiTestResult,
+> = (context: ApiTestHandlerContext<ApiSchema, BeforeApiTestResult>) => Promise<ApiTestResult>
+export interface AfterApiTestContext<
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+  ApiTestResult,
+> {
+  apiSchema: ApiSchema
+  beforeApiTestResult: BeforeApiTestResult
+  apiTestResult: ApiTestResult
+}
+export type AfterApiTestHandler<
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+  ApiTestResult,
+  AfterApiTestResult,
+> = (context: AfterApiTestContext<ApiSchema, BeforeApiTestResult, ApiTestResult>) => Promise<AfterApiTestResult>
+
+export interface ApiTestOptions<
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+  ApiTestResult,
+  AfterApiTestResult,
+> extends LoggerFriendlyOptions {
+  apiSchema: ApiSchema
+  beforeApiTestHandler: BeforeApiTestHandler<ApiSchema, BeforeApiTestResult>
+  apiTestHandler: ApiTestHandler<ApiSchema, BeforeApiTestResult, ApiTestResult>
+  afterApiTestHandler: AfterApiTestHandler<ApiSchema, BeforeApiTestResult, ApiTestResult, AfterApiTestResult>
+}
+export class ApiTest<
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+  ApiTestResult,
+  AfterApiTestResult,
+> implements LoggerFriendly {
+  readonly logger: Logger
+
+  protected __ApiSchemaPhantomType__?: ApiSchema
+  protected __BeforeApiTestResultPhantomType__?: BeforeApiTestResult
+  protected __ApiTestResultPhantomType__?: ApiTestResult
+  protected __AfterApiTestResultPhantomType__?: AfterApiTestResult
+
+  private apiSchema: ApiSchema
+  private beforeApiTestHandler: BeforeApiTestHandler<ApiSchema, BeforeApiTestResult>
+  private apiTestHandler: ApiTestHandler<ApiSchema, BeforeApiTestResult, ApiTestResult>
+  private afterApiTestHandler: AfterApiTestHandler<ApiSchema, BeforeApiTestResult, ApiTestResult, AfterApiTestResult>
+
+  constructor(options: ApiTestOptions<ApiSchema, BeforeApiTestResult, ApiTestResult, AfterApiTestResult>) {
+    this.logger = Logger.fromOptions(options).setDefaultName("ApiTest")
+
+    this.apiSchema = options.apiSchema
+    this.beforeApiTestHandler = options.beforeApiTestHandler
+    this.apiTestHandler = options.apiTestHandler
+    this.afterApiTestHandler = options.afterApiTestHandler
+  }
+
+  getApiSchema(): ApiSchema {
+    return this.apiSchema
+  }
+
+  getBeforeApiTestHandler(): BeforeApiTestHandler<ApiSchema, BeforeApiTestResult> {
+    return this.beforeApiTestHandler
+  }
+
+  getApiTestHandler(): ApiTestHandler<ApiSchema, BeforeApiTestResult, ApiTestResult> {
+    return this.apiTestHandler
+  }
+
+  getAfterApiTestHandler(): AfterApiTestHandler<ApiSchema, BeforeApiTestResult, ApiTestResult, AfterApiTestResult> {
+    return this.afterApiTestHandler
+  }
+}
+
+export const createApiTest = <
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+  ApiTestResult,
+  AfterApiTestResult,
+>(
+  options: ApiTestOptions<ApiSchema, BeforeApiTestResult, ApiTestResult, AfterApiTestResult>,
+): ApiTest<ApiSchema, BeforeApiTestResult, ApiTestResult, AfterApiTestResult> => {
+  return new ApiTest(options)
+}
+
+// oxlint-disable-next-line typescript/no-explicit-any
+export type AnyApiTest = ApiTest<any, any, any, any>
+
+export interface TestApiOptions<
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+  ApiTestResult,
+  AfterApiTestResult,
+> {
+  apiTest: ApiTest<ApiSchema, BeforeApiTestResult, ApiTestResult, AfterApiTestResult>
+}
+export const testApi = async <
+  ApiSchema extends AnyApiSchema,
+  BeforeApiTestResult,
+  ApiTestResult,
+  AfterApiTestResult,
+>(
+  options: TestApiOptions<ApiSchema, BeforeApiTestResult, ApiTestResult, AfterApiTestResult>,
+): Promise<AfterApiTestResult> => {
+  const { apiTest } = options
+
+  const apiSchema = apiTest.getApiSchema()
+
+  const beforeApiTestHandler = apiTest.getBeforeApiTestHandler()
+  const beforeApiTestResult = await beforeApiTestHandler({ apiSchema })
+
+  const apiTestHandler = apiTest.getApiTestHandler()
+  const apiTestResult = await apiTestHandler({ apiSchema, beforeApiTestResult })
+
+  const afterApiTestHandler = apiTest.getAfterApiTestHandler()
+  const afterApiTestResult = await afterApiTestHandler({ apiSchema, beforeApiTestResult, apiTestResult })
+
+  return afterApiTestResult
+}

package/src/http/api/api-type.ts

@@ -0,0 +1,37 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+
+import type { AnyApiSchema, ApiSchema } from './api-schema.ts';
+
+export type ApiType<Target extends AnyApiSchema> = Target extends ApiSchema<
+  infer Path,
+  infer Method,
+  infer InputQuerySchema,
+  infer InputBodySchema,
+  infer OutputSuccessSchema,
+  infer OutputErrorSchema
+> ? {
+  path: Path
+  method: Method
+  inputQuery: StandardSchemaV1.InferOutput<InputQuerySchema>
+  inputBody: StandardSchemaV1.InferOutput<InputBodySchema>
+  outputSuccess: StandardSchemaV1.InferOutput<OutputSuccessSchema>
+  outputError: StandardSchemaV1.InferOutput<OutputErrorSchema>
+} : never
+export const apiType = <const Target extends AnyApiSchema>(apiSchema: Target): ApiType<Target> => {
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  return apiSchema as unknown as ApiType<Target>
+}
+
+export type ApiTypesInTuple<Target extends readonly AnyApiSchema[]> = {
+  [Index in keyof Target]: ApiType<Target[Index]>
+}
+export const apiTypesInTuple = <const Target extends readonly AnyApiSchema[]>(apiSchemas: Target): ApiTypesInTuple<Target> => {
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  return apiSchemas.map(apiSchema => apiType(apiSchema)) as unknown as ApiTypesInTuple<Target>
+}
+
+export type ApiTypesInUnion<Target extends readonly AnyApiSchema[]> = ApiType<Target[number]>
+export const apiTypesInUnion = <const Target extends readonly AnyApiSchema[]>(apiSchemas: Target): ApiTypesInUnion<Target> => {
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  return apiSchemas.map(apiSchema => apiType(apiSchema)) as unknown as ApiTypesInUnion<Target>
+}

package/src/http/api/api.ts

@@ -0,0 +1,81 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import { Logger } from "#Source/log/index.ts"
+
+import type { ApiSchema } from "./api-schema.ts"
+import type { ApiHandler } from "./api-handler.ts"
+
+export interface ApiOptions<
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends StandardSchemaV1,
+  InputBodySchema extends StandardSchemaV1,
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+> extends LoggerFriendlyOptions {
+  apiSchema: ApiSchema<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>
+  apiHandler: ApiHandler<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>
+}
+/**
+ * Api 应该严格遵循 {@link ApiSchema} 的描述进行实现。
+ *
+ * 当一个请求被 {@link ApiServer} 按照路径（Path）和方法（Method）匹配到一个接口后，
+ * 便会开始按照 {@link Api} 的逻辑对请求进行处理。
+ *
+ * Api 的整个处理流程如下：
+ *
+ * 请求 -> 构造上下文 -> 处理器（Api Runner） -> 返回结果（Result）
+ *
+ * 其中：
+ * - 构造上下文包括：
+ *   - 从处理原始请求并从中提取输入数据，主要来自 query 和 body。
+ *   - 校验输入数据，确保输入数据符合 {@link ApiSchema} 的描述。
+ * - 处理器是 Api 的核心逻辑，负责对请求进行处理，可以包含副作用，比如查询数据库、调用其他服务等。
+ * - 一般情况下，处理器不应该直接返回数据给前端，而应该通过 {@link SuccessResult} 或 {@link ErrorResult}
+ *   定义自己想要返回什么，然后 {@link ApiServer} 会负责执行返回逻辑，将结果返回给前端，这样做既可以使 Api 的
+ *   核心逻辑更纯粹，也可以保证所有的接口始终给前端返回一致的数据结构。
+ */
+export class Api<
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends StandardSchemaV1,
+  InputBodySchema extends StandardSchemaV1,
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+> implements LoggerFriendly {
+  readonly logger: Logger
+
+  private readonly apiSchema: ApiSchema<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>
+  private readonly apiHandler: ApiHandler<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>
+
+  constructor(options: ApiOptions<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>) {
+    this.logger = Logger.fromOptions(options).setDefaultName("Api")
+
+    this.apiSchema = options.apiSchema
+    this.apiHandler = options.apiHandler
+  }
+
+  getApiSchema(): ApiSchema<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema> {
+    return this.apiSchema
+  }
+
+  getApiHandler(): ApiHandler<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema> {
+    return this.apiHandler
+  }
+}
+
+export const createApi = <
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends StandardSchemaV1,
+  InputBodySchema extends StandardSchemaV1,
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+>(
+  options: ApiOptions<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>,
+): Api<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema> => {
+  return new Api(options)
+}
+
+export type AnyApi = Api<string, "get" | "post", StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1>

package/src/http/api/index.ts

@@ -0,0 +1,11 @@
+export * from "./api-core.ts"
+export * from "./api-host.ts"
+
+export * from "./api-result.ts"
+export * from "./api-schema.ts"
+export * from "./api-type.ts"
+export type * from "./api-handler.ts"
+export * from "./api.ts"
+
+export * from "./api-test.ts"
+export * from "./api-server.ts"

package/src/http/api-adapter/api-core-node-http.ts

@@ -0,0 +1,260 @@
+import type { IncomingMessage, ServerResponse } from "node:http"
+
+import type {
+  ApiCoreHeaders,
+  ApiCoreRequestFormData,
+  ApiCoreStream,
+} from "../api/api-core.ts"
+import { ApiCore } from "../api/api-core.ts"
+
+export class NodeHttpApiCoreStream implements ApiCoreStream {
+  protected readonly response: ServerResponse<IncomingMessage>
+
+  constructor(response: ServerResponse<IncomingMessage>) {
+    this.response = response
+  }
+
+  async write(chunk: Buffer | string, encoding: BufferEncoding): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      this.response.write(chunk, encoding, (error) => {
+        if (error !== undefined) {
+          reject(error instanceof Error ? error : new Error(String(error)))
+          return
+        }
+
+        resolve()
+      })
+    })
+  }
+
+  async end(): Promise<void> {
+    await new Promise<void>((resolve) => {
+      this.response.end(() => {
+        resolve()
+      })
+    })
+  }
+}
+
+export interface ApiCoreNodeHttpOptions {
+  request: IncomingMessage
+  response: ServerResponse<IncomingMessage>
+}
+export class ApiCoreNodeHttp extends ApiCore {
+  protected readonly request: IncomingMessage
+  protected readonly response: ServerResponse<IncomingMessage>
+
+  protected requestUrl: URL | undefined
+  protected bodyBufferTask: Promise<Buffer> | undefined
+  protected bodyTextTask: Promise<string> | undefined
+  protected bodyFormDataTask: Promise<ApiCoreRequestFormData> | undefined
+
+  constructor(options: ApiCoreNodeHttpOptions) {
+    super()
+
+    this.request = options.request
+    this.response = options.response
+
+    this.bodyBufferTask = undefined
+    this.bodyTextTask = undefined
+    this.bodyFormDataTask = undefined
+    this.requestUrl = undefined
+  }
+
+  async getRequestHeaders(): Promise<ApiCoreHeaders> {
+    const headers: ApiCoreHeaders = {}
+
+    for (const [name, rawValue] of Object.entries(this.request.headers)) {
+      if (Array.isArray(rawValue)) {
+        const [firstValue, ...restValues] = rawValue
+
+        if (firstValue === undefined) {
+          headers[name] = undefined
+          continue
+        }
+
+        headers[name] = [firstValue, ...restValues]
+        continue
+      }
+
+      headers[name] = rawValue === undefined ? undefined : [rawValue]
+    }
+
+    return await Promise.resolve(headers)
+  }
+
+  getRequestUrl(): string {
+    let requestUrl = this.requestUrl
+
+    if (requestUrl === undefined) {
+      const partialUrl = this.request.url ?? "/"
+      const host = this.request.headers.host
+
+      if (host === undefined || host.length === 0) {
+        requestUrl = new URL(partialUrl, "http://127.0.0.1")
+      } else {
+        requestUrl = new URL(partialUrl, `http://${host}`)
+      }
+      this.requestUrl = requestUrl
+    }
+
+    return requestUrl.href
+  }
+
+  async getRequestMethod(): Promise<string> {
+    const method = this.request.method ?? "GET"
+    return await Promise.resolve(method)
+  }
+
+  protected async getRequestBodyBuffer(): Promise<Buffer> {
+    if (this.bodyBufferTask !== undefined) {
+      return await this.bodyBufferTask
+    }
+
+    this.bodyBufferTask = new Promise<Buffer>((resolve, reject) => {
+      const chunks: Buffer[] = []
+
+      this.request.on("data", (chunk: Buffer | string) => {
+        if (typeof chunk === "string") {
+          chunks.push(Buffer.from(chunk))
+          return
+        }
+
+        chunks.push(chunk)
+      })
+
+      this.request.once("aborted", () => {
+        reject(new Error("Request body was aborted."))
+      })
+
+      this.request.once("error", (error) => {
+        reject(error)
+      })
+
+      this.request.once("end", () => {
+        resolve(Buffer.concat(chunks))
+      })
+    })
+
+    return await this.bodyBufferTask
+  }
+
+  async getRequestBodyText(): Promise<string> {
+    if (this.bodyTextTask !== undefined) {
+      return await this.bodyTextTask
+    }
+
+    this.bodyTextTask = this.getRequestBodyBuffer().then((bodyBuffer) => {
+      return bodyBuffer.toString("utf8")
+    })
+
+    return await this.bodyTextTask
+  }
+
+  async getRequestBodyFormData(): Promise<ApiCoreRequestFormData> {
+    if (this.bodyFormDataTask !== undefined) {
+      return await this.bodyFormDataTask
+    }
+
+    this.bodyFormDataTask = (async () => {
+      const contentType = this.request.headers["content-type"]
+
+      if (
+        contentType === undefined
+        || /^(application\/x-www-form-urlencoded|multipart\/form-data)\b/i.test(contentType) === false
+      ) {
+        return []
+      }
+
+      const bodyBuffer = await this.getRequestBodyBuffer()
+      const requestHeaders = Object.entries(await this.getRequestHeaders()).flatMap(([name, value]) => {
+        if (value === undefined) {
+          return []
+        }
+
+        return value.map((item) => {
+          return [name, item] as [string, string]
+        })
+      })
+      const request = new Request(this.getRequestUrl(), {
+        method: await this.getRequestMethod(),
+        headers: requestHeaders,
+        body: new Uint8Array(bodyBuffer),
+      })
+      const formData = await request.formData()
+
+      return Array.from(formData.entries()).map(([name, value]) => {
+        return {
+          name,
+          value,
+        }
+      })
+    })()
+
+    return await this.bodyFormDataTask
+  }
+
+  protected prepareResponse(contentType: string, statusCode: number = 200): void {
+    if (this.response.writableEnded === true) {
+      return
+    }
+
+    if (this.response.headersSent === false) {
+      this.response.statusCode = statusCode
+      this.response.setHeader("Content-Type", contentType)
+    }
+  }
+
+  async text(data: unknown): Promise<void> {
+    this.prepareResponse("text/plain; charset=utf-8")
+
+    await new Promise<void>((resolve) => {
+      this.response.end(String(data), () => {
+        resolve()
+      })
+    })
+  }
+
+  async json(data: unknown): Promise<void> {
+    this.prepareResponse("application/json; charset=utf-8")
+
+    await new Promise<void>((resolve) => {
+      this.response.end(JSON.stringify(data), () => {
+        resolve()
+      })
+    })
+  }
+
+  async stream(): Promise<ApiCoreStream> {
+    this.prepareResponse("text/event-stream; charset=utf-8")
+    this.response.setHeader("Cache-Control", "no-cache")
+    this.response.setHeader("Connection", "keep-alive")
+    this.response.flushHeaders()
+
+    const stream = new NodeHttpApiCoreStream(this.response)
+    return await Promise.resolve(stream)
+  }
+
+  async error(): Promise<void> {
+    if (this.response.writableEnded === true) {
+      return await Promise.resolve()
+    }
+
+    this.prepareResponse("application/json; charset=utf-8", 500)
+
+    await new Promise<void>((resolve) => {
+      this.response.end(JSON.stringify({
+        status: "error",
+        data: {
+          reason: "internal_server_error",
+        },
+      }), () => {
+        resolve()
+      })
+    })
+  }
+}
+
+export const createApiCoreNodeHttp = (options: ApiCoreNodeHttpOptions): ApiCoreNodeHttp => {
+  return new ApiCoreNodeHttp(options)
+}