@planet-matrix/mobius-model 0.6.0 → 0.9.0

package/src/http/api-adapter/api-result-zod.ts

@@ -0,0 +1,286 @@
+import { z } from "zod"
+
+import { generateUuidV4 } from "#Source/identifier/uuid.ts"
+
+import type { ApiCore, ApiCoreStream } from "../api/api-core.ts"
+import type { SuccessResultOptions, ErrorResultOptions } from "../api/api-result.ts"
+import type { ApiHandlerContext } from "../api/api-handler.ts"
+
+import { SuccessResult, ErrorResult } from "../api/api-result.ts"
+
+export interface JsonSuccessResultOptions<Data> extends SuccessResultOptions<Data> {
+  data: Data
+}
+export class JsonSuccessResult<Data> extends SuccessResult<Data> {
+  protected declare options: JsonSuccessResultOptions<Data>
+
+  constructor(options: JsonSuccessResultOptions<Data>) {
+    super(options)
+    this.logger.setDefaultName("JsonSuccessResult")
+  }
+
+  async handle(apiCore: ApiCore): Promise<void> {
+    const { data } = this.options
+
+    this.logger.log(`send, ${JSON.stringify(data, null, 2)}`)
+    await apiCore.json(data)
+    this.logger.log(`end`)
+  }
+}
+
+export interface CommonSuccessJson<Data> {
+  status: "success"
+  data: Data
+}
+export interface CommonJsonSuccessResultOptions<Data>
+  extends Omit<JsonSuccessResultOptions<CommonSuccessJson<Data>>, "data"> {
+  data: Data
+}
+export class CommonJsonSuccessResult<Data>
+  extends JsonSuccessResult<CommonSuccessJson<Data>> {
+  protected declare options: JsonSuccessResultOptions<CommonSuccessJson<Data>>
+
+  constructor(options: CommonJsonSuccessResultOptions<Data>) {
+    super({
+      ...options,
+      data: {
+        status: "success",
+        data: options.data,
+      },
+    })
+    this.logger.setDefaultName("CommonJsonSuccessResult")
+  }
+}
+export const commonJsonSuccessResult = <Data>(
+  options: CommonJsonSuccessResultOptions<Data>
+): CommonJsonSuccessResult<Data> => {
+  return new CommonJsonSuccessResult<Data>(options)
+}
+
+export type CommonJsonSuccessResultSchema<DataSchema extends z.ZodObject> = z.ZodObject<{
+  status: z.ZodLiteral<"success">
+  data: DataSchema
+}>
+export type GetDataSchemaFromCommonJsonSuccessResultSchema<Schema extends z.ZodType>
+  = Schema extends CommonJsonSuccessResultSchema<infer DataSchema> ? DataSchema : never
+export type GetDataFromCommonJsonSuccessResultSchema<Schema extends z.ZodType>
+  = Schema extends CommonJsonSuccessResultSchema<infer DataSchema> ? z.infer<DataSchema> : never
+export const commonJsonSuccessResultSchema = <DataSchema extends z.ZodObject>(
+  dataSchema: DataSchema,
+): CommonJsonSuccessResultSchema<DataSchema> => {
+  return z.object({
+    status: z.literal("success"),
+    data: dataSchema,
+  })
+}
+
+export type StreamWrite = (chunk: Buffer | string, encoding: BufferEncoding) => void | Promise<void>
+export type StreamEnd = () => void | Promise<void>
+export interface StreamSuccessResultOptions extends SuccessResultOptions<unknown> {
+  writeHandler: (write: StreamWrite) => Promise<void>
+}
+export class StreamSuccessResult extends SuccessResult<unknown> {
+  protected declare options: StreamSuccessResultOptions
+
+  protected streamId: string
+
+  constructor(options: StreamSuccessResultOptions) {
+    super(options)
+    this.logger.setDefaultName("StreamSuccessResult")
+    this.streamId = generateUuidV4()
+  }
+
+  async handle(apiCore: ApiCore): Promise<void> {
+    const apiCoreStream = await apiCore.stream()
+
+    const write = this.wrapWrite(apiCoreStream)
+    await this.options.writeHandler(write)
+    const end = this.wrapEnd(apiCoreStream)
+    await end()
+  }
+
+  /**
+   * 把 write 方法包装一下，以达到注入日志等目的。
+   */
+  protected wrapWrite(apiCoreStream: ApiCoreStream): StreamWrite {
+    return async (chunk, encoding): Promise<void> => {
+      this.logger.log(`send, id: ${this.streamId}, data: ${String(chunk)}`)
+      await apiCoreStream.write(chunk, encoding)
+    }
+  }
+
+  /**
+   * 把 end 方法包装一下，以达到注入日志等目的。
+   */
+  protected wrapEnd(apiCoreStream: ApiCoreStream): StreamEnd {
+    const end = async (): Promise<void> => {
+      this.logger.log(`end, id: ${this.streamId}`)
+      await apiCoreStream.end()
+    }
+    return end
+  }
+}
+
+export type CustomHandler = (apiCore: ApiCore) => Promise<void>
+export interface CustomSuccessResultOptions extends SuccessResultOptions<unknown> {
+  customHandler: CustomHandler
+}
+export class CustomSuccessResult extends SuccessResult<unknown> {
+  protected declare options: CustomSuccessResultOptions
+
+  constructor(options: CustomSuccessResultOptions) {
+    super(options)
+    this.logger.setDefaultName("CustomSuccessResult")
+  }
+
+  async handle(apiCore: ApiCore): Promise<void> {
+    this.logger.log(`send`)
+    await this.options.customHandler(apiCore)
+    this.logger.log(`end`)
+  }
+}
+
+// ======================
+
+export interface JsonErrorResultOptions<Data> extends ErrorResultOptions<Data> {
+  data: Data
+}
+export class JsonErrorResult<Data> extends ErrorResult<Data> {
+  protected declare options: JsonErrorResultOptions<Data>
+
+  constructor(options: JsonErrorResultOptions<Data>) {
+    super(options)
+    this.logger.setDefaultName("JsonErrorResult")
+  }
+
+  async handle(apiCore: ApiCore): Promise<void> {
+    const { data } = this.options
+
+    this.logger.log(`send, ${JSON.stringify(data, null, 2)}`)
+    await apiCore.json(data)
+    this.logger.log(`end`)
+  }
+}
+
+export interface CommonErrorJsonData<Reason> {
+  reason: Reason
+  reasonDetail?: string | undefined
+}
+export interface CommonErrorJson<Reason> {
+  status: "error"
+  data: CommonErrorJsonData<Reason>
+}
+export interface CommonJsonErrorResultOptions<Reason>
+  extends Omit<JsonErrorResultOptions<CommonErrorJson<Reason>>, "data">,
+  CommonErrorJsonData<Reason> {
+}
+export class CommonJsonErrorResult<const Reason>
+  extends JsonErrorResult<CommonErrorJson<Reason>> {
+  protected declare options: JsonErrorResultOptions<CommonErrorJson<Reason>>
+
+  constructor(options: CommonJsonErrorResultOptions<Reason>) {
+    super({
+      ...options,
+      data: {
+        status: "error",
+        data: {
+          reason: options.reason,
+          reasonDetail: options.reasonDetail,
+        },
+      },
+    })
+    this.logger.setDefaultName("CommonJsonErrorResult")
+  }
+}
+export const commonJsonErrorResult = <const Reason>(
+  options: CommonJsonErrorResultOptions<Reason>
+): CommonJsonErrorResult<Reason> => {
+  return new CommonJsonErrorResult<Reason>(options)
+}
+
+export type CommonJsonErrorResultSchema<
+  DataSchema extends z.ZodObject<{
+    reason: z.ZodEnum<Readonly<Record<string, string>>>
+    reasonDetail?: z.ZodString | z.ZodNull | z.ZodUndefined
+  }>
+> = z.ZodObject<{
+  status: z.ZodLiteral<"error">
+  data: z.ZodObject<DataSchema["shape"] & {
+    reasonDetail: z.ZodString | z.ZodNull | z.ZodUndefined
+  }>
+}>
+export type GetDataSchemaFromCommonJsonErrorResultSchema<Schema extends z.ZodType>
+  = Schema extends CommonJsonErrorResultSchema<infer DataSchema> ? DataSchema : never
+export type GetDataFromCommonJsonErrorResultSchema<Schema extends z.ZodType>
+  = Schema extends CommonJsonErrorResultSchema<infer DataSchema> ? z.infer<DataSchema> : never
+export type GetReasonFromCommonJsonErrorResultSchema<Schema extends z.ZodType>
+  = Schema extends CommonJsonErrorResultSchema<infer DataSchema>
+  ? z.infer<DataSchema> extends { reason: infer Reason } ? Reason : never
+  : never
+export const commonJsonErrorResultSchema = <
+  DataSchema extends z.ZodObject<{
+    reason: z.ZodEnum<Readonly<Record<string, string>>>
+    reasonDetail?: z.ZodString | z.ZodNull | z.ZodUndefined
+  }>
+>(
+  dataSchema: DataSchema
+): CommonJsonErrorResultSchema<DataSchema> => {
+  const newOutputErrorSchema = z.object({
+    status: z.literal("error"),
+    data: dataSchema.extend({
+      reasonDetail: z.string(),
+    }),
+  })
+  return newOutputErrorSchema
+}
+
+// ======================
+
+export type ContextWithResultHandler<
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends z.ZodType,
+  InputBodySchema extends z.ZodType,
+  OutputSuccessSchema extends z.ZodType,
+  OutputErrorSchema extends z.ZodType,
+>
+  = ApiHandlerContext<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>
+  & {
+    commonJsonSuccessResult: (
+      options: CommonJsonSuccessResultOptions<GetDataFromCommonJsonSuccessResultSchema<OutputSuccessSchema>>
+    ) => CommonJsonSuccessResult<GetDataFromCommonJsonSuccessResultSchema<OutputSuccessSchema>>
+    commonJsonErrorResult: (
+      options: CommonJsonErrorResultOptions<GetReasonFromCommonJsonErrorResultSchema<OutputErrorSchema>>
+    ) => CommonJsonErrorResult<GetReasonFromCommonJsonErrorResultSchema<OutputErrorSchema>>
+  }
+
+export const withResultHandler = <
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends z.ZodType,
+  InputBodySchema extends z.ZodType,
+  OutputSuccessSchema extends z.ZodType,
+  OutputErrorSchema extends z.ZodType,
+>(
+  context: ApiHandlerContext<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>,
+): ContextWithResultHandler<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema> => {
+  return {
+    ...context,
+    commonJsonSuccessResult: (
+      options: CommonJsonSuccessResultOptions<GetDataFromCommonJsonSuccessResultSchema<OutputSuccessSchema>>,
+    ) => {
+      return commonJsonSuccessResult({
+        logger: context.logger,
+        ...options,
+      })
+    },
+    commonJsonErrorResult: (
+      options: CommonJsonErrorResultOptions<GetReasonFromCommonJsonErrorResultSchema<OutputErrorSchema>>,
+    ) => {
+      return commonJsonErrorResult<GetReasonFromCommonJsonErrorResultSchema<OutputErrorSchema>>({
+        logger: context.logger,
+        ...options,
+      })
+    },
+  }
+}

package/src/http/api-adapter/index.ts

@@ -0,0 +1,5 @@
+export * from "./api-result-arktype.ts"
+export * as Zod from "./api-result-zod.ts"
+
+export * from "./api-core-node-http.ts"
+export * from "./api-host-node-http.ts"

package/src/http/bin/gen-api-list/gen-api-list.ts

@@ -0,0 +1,126 @@
+import fs, { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import ts from "typescript"
+
+import { getGlobalLogger } from "#Source/log/index.ts"
+
+export interface GenerateApiListOptions {
+  importFrom: string
+  /**
+   * Path to tsconfig.json file.
+   */
+  tsconfigFilePath: string
+  /**
+   * Path to Api folder.
+   */
+  apiFolderPath: string
+  /**
+   * Path to output file.
+   */
+  outputFilePath: string
+}
+const toAbsolutePath = (options: GenerateApiListOptions): GenerateApiListOptions => {
+  const { tsconfigFilePath, apiFolderPath, outputFilePath } = options
+  const absoluteTsconfigFilePath = path.resolve(tsconfigFilePath)
+  const absoluteApiFolderPath = path.resolve(apiFolderPath)
+  const absoluteOutputFilePath = path.resolve(outputFilePath)
+  console.log("tsconfigFilePath:", absoluteTsconfigFilePath)
+  console.log("apiFolderPath:", absoluteApiFolderPath)
+  console.log("outputFilePath:", absoluteOutputFilePath)
+  return {
+    ...options,
+    tsconfigFilePath: absoluteTsconfigFilePath,
+    apiFolderPath: absoluteApiFolderPath,
+    outputFilePath: absoluteOutputFilePath,
+  }
+}
+export const generateApiList = (options: GenerateApiListOptions): void => {
+  const {
+    importFrom,
+    tsconfigFilePath,
+    apiFolderPath,
+    outputFilePath,
+  } = toAbsolutePath(options)
+  const logger = getGlobalLogger()
+
+  // const _projectRootPath = path.dirname(tsconfigFilePath)
+
+  const tsconfigJson = ts.parseConfigFileTextToJson(tsconfigFilePath, fs.readFileSync(tsconfigFilePath, "utf8"))
+  if (tsconfigJson.error) {
+    throw new Error("无法解析 tsconfig.json")
+  }
+  const parsedTsconfig = ts.parseJsonConfigFileContent(tsconfigJson.config, ts.sys, path.resolve(tsconfigFilePath, ".."))
+  logger.debug("成功解析 tsconfig 文件...")
+
+  const projectHost = ts.createCompilerHost(parsedTsconfig.options)
+  const project = ts.createProgram(parsedTsconfig.fileNames, parsedTsconfig.options, projectHost)
+  logger.debug("成功读取项目...")
+
+  // 不可以删除, 否则会变得不幸
+  // NOTE: Gets a type checker that can be used to semantically analyze source files in the program.
+  // const _check = project.getTypeChecker()
+
+  const allSourceFiles = project.getSourceFiles()
+  const apiSourceFiles = allSourceFiles.filter((sourceFile) => {
+    // 我们约定接口实现必须名为 index.ts
+    // oxlint-disable-next-line no-useless-escape unicorn/prefer-string-raw
+    return new RegExp(`${apiFolderPath.replaceAll("\\", "\\\\")}.*index\.ts`).test(path.resolve(sourceFile.fileName))
+  })
+
+  logger.debug(`找到 ${apiSourceFiles.length} 个接口`)
+
+  const importArea: string[] = []
+  const codeArea: string[] = []
+  apiSourceFiles.forEach((apiSourceFile, index) => {
+    // For example:
+    //  - apiFolderPath: C:\Users\xxx\Desktop\Codespace\web-core\test\test-project\src\interface
+    //  - apiSourceFile.fileName: C:/Users/xxx/Desktop/Codespace/web-core/test/test-project/src/interface/add/index.ts
+    //  - filenameRelativeToApiFolder: add/index.ts
+    //  - filenameRelativeToApiFolder: ./add/index.ts --- sometimes
+    const filenameRelativeToApiFolder = path.relative(apiFolderPath, apiSourceFile.fileName).replaceAll("\\", "/")
+    // For example:
+    //  - importName: add -- from add/index.ts
+    //  - importName: user_get_user_info -- from user/get-user-info.ts
+    const importName = filenameRelativeToApiFolder.replaceAll("/", "_").replaceAll(".ts", "").replaceAll("./", "").replaceAll("-", "_")
+    // For example:
+    //  - outputFilePath: C:\Users\xxx\Desktop\Codespace\web-core\test\test-project\interface\api-list.ts
+    //  - outputFolderRelativeToApiFolder: ''
+    const outputFolderRelativeToApiFolder = path.relative(path.dirname(outputFilePath), apiFolderPath).replaceAll("\\", "/")
+    // For example:
+    //  - importPath: ./add/index
+    const importPath = outputFolderRelativeToApiFolder === ""
+      ? `./${filenameRelativeToApiFolder}`.replaceAll("\\", "/").replaceAll(".ts", "")
+      : path.join(outputFolderRelativeToApiFolder, filenameRelativeToApiFolder).replaceAll("\\", "/").replaceAll(".ts", "")
+
+    logger.info(`处理（${index + 1} / ${apiSourceFiles.length}）：${filenameRelativeToApiFolder}`)
+
+    for (const node of apiSourceFile.statements) {
+      if (ts.isExportAssignment(node) && node.isExportEquals === undefined) {
+        const expression = node.expression
+        if (ts.isNewExpression(expression) && expression.expression.getText() === "Api") {
+          break
+        }
+        throw new Error(`${apiSourceFile.fileName}：不是 Api`)
+      }
+    }
+
+    importArea.push(`import ${importName} from '${importPath}'`)
+    codeArea.push(`${String(importName)}`)
+  })
+
+  const finalTestFile = [
+    `import type { AnyApi } from '${importFrom}'`,
+    "",
+    ...importArea,
+    "",
+    `export const apiList: AnyApi[] = [\n${codeArea.map(a => `  ${String(a)}`).join(",\n")}\n]`,
+    "",
+  ].join("\n")
+
+  const outDir = path.dirname(outputFilePath)
+  if (existsSync(outDir) === false) {
+    mkdirSync(outDir, { recursive: true })
+  }
+
+  writeFileSync(outputFilePath, finalTestFile)
+}

package/src/http/bin/gen-api-list/index.ts

@@ -0,0 +1 @@
+export * from "./gen-api-list.ts"

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

@@ -0,0 +1,136 @@
+import fs, { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import ts from "typescript"
+
+import { getGlobalLogger } from "#Source/log/index.ts"
+
+export interface GenerateApiTestOptions {
+  importFrom: string
+  tsconfigFilePath: string
+  apiFolderPath: string
+  outputFilePath: string
+  apiFileFilter: string
+}
+const toAbsolutePath = (options: GenerateApiTestOptions): GenerateApiTestOptions => {
+  const { tsconfigFilePath, apiFolderPath, outputFilePath } = options
+  const absoluteTsconfigFilePath = path.resolve(tsconfigFilePath)
+  const absoluteApiFolderPath = path.resolve(apiFolderPath)
+  const absoluteOutputFilePath = path.resolve(outputFilePath)
+  console.log("tsconfigFilePath:", absoluteTsconfigFilePath)
+  console.log("apiFolderPath:", absoluteApiFolderPath)
+  console.log("outputFilePath:", absoluteOutputFilePath)
+  return {
+    ...options,
+    tsconfigFilePath: absoluteTsconfigFilePath,
+    apiFolderPath: absoluteApiFolderPath,
+    outputFilePath: absoluteOutputFilePath,
+  }
+}
+export const generateApiText = (options: GenerateApiTestOptions): void => {
+  const {
+    importFrom,
+    tsconfigFilePath,
+    apiFolderPath,
+    outputFilePath,
+    apiFileFilter,
+  } = toAbsolutePath(options)
+  const logger = getGlobalLogger()
+
+  const projectRootPath = path.dirname(tsconfigFilePath)
+
+  const tsconfigJson = ts.parseConfigFileTextToJson(tsconfigFilePath, fs.readFileSync(tsconfigFilePath, "utf8"))
+  if (tsconfigJson.error) {
+    throw new Error("无法解析 tsconfig.json")
+  }
+  const parsedTsconfig = ts.parseJsonConfigFileContent(tsconfigJson.config, ts.sys, path.resolve(tsconfigFilePath, ".."))
+  logger.debug("成功解析 tsconfig 文件...")
+
+  const projectHost = ts.createCompilerHost(parsedTsconfig.options)
+  const project = ts.createProgram(parsedTsconfig.fileNames, parsedTsconfig.options, projectHost)
+  logger.debug("成功读取项目...")
+
+  // 不可以删除, 否则会变得不幸
+  // NOTE: Gets a type checker that can be used to semantically analyze source files in the program.
+  // const _check = project.getTypeChecker()
+
+  const allSourceFiles = project.getSourceFiles()
+  const typeSourceFiles = allSourceFiles.filter((sourceFile) => {
+    // 我们约定接口蓝图必须名为 type.ts
+    // oxlint-disable-next-line no-useless-escape unicorn/prefer-string-raw
+    return new RegExp(`${apiFolderPath.replaceAll("\\", "\\\\")}.*type\.ts`).test(path.resolve(sourceFile.fileName))
+  })
+  const testSourceFiles = allSourceFiles.filter((sourceFile) => {
+    // oxlint-disable-next-line no-useless-escape unicorn/prefer-string-raw
+    return new RegExp(`${apiFolderPath.replaceAll("\\", "\\\\")}.*\.test\.ts`).test(path.resolve(sourceFile.fileName))
+  })
+
+  const testSourceFilesFilter = testSourceFiles.filter((sourceFile) => {
+    return new RegExp(apiFileFilter).test(path.resolve(sourceFile.fileName))
+  })
+  // TODO: 这里可以明确打印出来谁有测试，谁没有测试。
+  logger.debug(`找到 ${typeSourceFiles.length} 个接口，其中有 ${testSourceFiles.length} 个测试，筛选后还剩 ${testSourceFilesFilter.length} 个...`)
+
+  const importCode: string[] = []
+  const testCode: string[] = []
+  testSourceFilesFilter.forEach((testSourceFile, index) => {
+    // For example:
+    //  - apiFolderPath: C:\Users\xxx\Desktop\Codespace\web-core\test\test-project\src\interface
+    //  - testSourceFile.fileName: C:/Users/xxx/Desktop/Codespace/web-core/test/test-project/src/interface/add/t01.test.ts
+    //  - filenameRelativeToApiFolder: add/t01.test.ts
+    //  - filenameRelativeToApiFolder: ./add/t01.test.ts --- sometimes
+    const filenameRelativeToApiFolder = path.relative(apiFolderPath, testSourceFile.fileName).replaceAll("\\", "/")
+    // For example:
+    //  - importName: add_t01 -- from add/t01.test.ts
+    //  - importName: get_user_info -- from get-user-info.test.ts
+    const importName = filenameRelativeToApiFolder.replaceAll("/", "_").replaceAll(".test.ts", "").replaceAll("./", "").replaceAll("-", "_")
+    // For example:
+    //  - projectRootPath: C:\Users\xxx\Desktop\Codespace\web-core\test\test-project
+    //  - filenameRelativeToProjectRoot: src/interface/add/t01.test
+    const filenameRelativeToProjectRoot = path.relative(projectRootPath, testSourceFile.fileName).replaceAll("\\", "/").replaceAll(".ts", "")
+    // For example:
+    //  - outputPath: C:\Users\xxx\Desktop\Codespace\web-core\test\test-project\test\test.ts
+    //  - outputFolderRelativeToProjectRoot: ../
+    const outputFolderRelativeToProjectRoot = path.relative(path.dirname(outputFilePath), projectRootPath).replaceAll("\\", "/")
+    // For example:
+    //  - importPath: ../src/interface/add/t01.test
+    const importPath = path.join(outputFolderRelativeToProjectRoot, filenameRelativeToProjectRoot).replaceAll("\\", "/")
+
+    logger.info(`处理（${index + 1} / ${testSourceFilesFilter.length}）：${filenameRelativeToApiFolder}`)
+
+    for (const node of testSourceFile.statements) {
+      if (ts.isExportAssignment(node) && node.isExportEquals === undefined) {
+        const expression = node.expression
+        if (ts.isNewExpression(expression) && expression.expression.getText() === "ApiTestSchema") {
+          break
+        }
+        throw new Error(`${testSourceFile.fileName}：不是 ApiTestSchema`)
+      }
+    }
+
+    importCode.push(`import ${importName} from '${importPath}'`)
+    testCode.push(generateTestCode(importName, importName))
+  })
+
+  const finalTestFile = [
+    "import { test } from 'vitest'",
+    `import { testApi } from '${importFrom}'`,
+    "",
+    "import './unit-test-prefix'",
+    "",
+    ...importCode,
+    "",
+    ...testCode,
+    "",
+  ].join("\n")
+
+  const outDir = path.dirname(outputFilePath)
+  if (existsSync(outDir) === false) {
+    mkdirSync(outDir, { recursive: true })
+  }
+
+  writeFileSync(outputFilePath, finalTestFile)
+}
+
+const generateTestCode = (testCaseName: string, importName: string): string => {
+  return `test('${testCaseName}', async () => await testApi({ apiTest: ${importName} }))`
+}

package/src/http/bin/gen-api-test/index.ts

@@ -0,0 +1 @@
+export * from "./gen-api-test.ts"

package/src/http/bin/gen-api-type/calc-code.ts

@@ -0,0 +1,25 @@
+export interface GetCalcCodeOptions {
+  importFrom: string
+}
+export const getCalcCode = (options: GetCalcCodeOptions): string => {
+  const { importFrom } = options
+  return `
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import type { ApiSchema } from "${importFrom}"
+
+import exportedApiSchema from "./type"
+
+type Api = (typeof exportedApiSchema) 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 default Api
+`
+}