@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/src/form/inputor-controller/select.ts

@@ -0,0 +1,109 @@
+// oxlint-disable typescript/no-explicit-any
+
+import type { BaseInputorContext, BaseInputorControllerOptions, BaseInputorSchema, InputorControllerInitializeHooks } from "./base.ts"
+import { BaseInputorController } from "./base.ts"
+
+export const SELECT_INPUTOR_TYPE_NAME = "select" as const
+export type SelectInputorTypeName = typeof SELECT_INPUTOR_TYPE_NAME
+
+export interface SelectOption<Value = any> {
+  name: string
+  label: string
+  value: Value
+  isSelected: boolean
+  description?: string | undefined
+  isDisabled?: boolean | undefined
+}
+export type SelectOptions<Value = any> = Array<SelectOption<Value>>
+export type SelectInputorExternalValue<Value = any> = SelectOptions<Value>
+export type SelectInputorInternalValue<Value = any> = SelectOptions<Value>
+export interface SelectInputorSchema<Value = any> extends BaseInputorSchema<SelectInputorExternalValue<Value>> {
+  inputorTypeName: SelectInputorTypeName
+}
+export interface SelectInputorContext<Value = any> extends BaseInputorContext<SelectInputorExternalValue<Value>, SelectInputorInternalValue<Value>> {
+}
+
+export interface SelectInputorControllerOptions<Value = any> extends BaseInputorControllerOptions<
+  SelectInputorExternalValue<Value>,
+  SelectInputorSchema<Value>
+> {
+  /**
+   * 是否允许取消选择。
+   *
+   * @default false
+   */
+  enableUnselect?: boolean
+}
+export class SelectInputorController<Value = any> extends BaseInputorController<
+  SelectInputorExternalValue<Value>,
+  SelectInputorInternalValue<Value>,
+  SelectInputorSchema<Value>,
+  SelectInputorContext<Value>
+> {
+  declare schemaType: SelectInputorSchema<Value>
+  declare optionsType: SelectInputorControllerOptions<Value>
+  declare constructorType: typeof SelectInputorController<Value>
+
+  static inputorTypeName: SelectInputorTypeName = SELECT_INPUTOR_TYPE_NAME
+
+  inputorTypeName: SelectInputorTypeName = SELECT_INPUTOR_TYPE_NAME
+  voidExternalValue = [] as SelectInputorExternalValue<Value>
+  voidInternalValue = [] as SelectInputorInternalValue<Value>
+
+  private enableUnselect!: boolean
+
+  constructor(options: SelectInputorControllerOptions<Value>) {
+    super(options)
+  }
+
+  protected override async initialize(
+    options: SelectInputorControllerOptions<Value>,
+    hooks?: InputorControllerInitializeHooks,
+  ): Promise<void> {
+    await super.initialize(options, {
+      ...hooks,
+      onSchemaReady: async () => {
+        this.enableUnselect = options.enableUnselect ?? false
+        await hooks?.onSchemaReady?.()
+      },
+    })
+  }
+
+  async select(name: string): Promise<void> {
+    if (this.isDisabled === true) {
+      return
+    }
+
+    const internalValue = this.getInternalValue()
+    const disabledSelectedName = internalValue.find(option => {
+      return option.isSelected && (option.isDisabled === true)
+    })?.name
+    const updatedInternalValue = internalValue.map((option) => {
+      const { name: optionName, isSelected: _isSelected, isDisabled } = option
+
+      if (disabledSelectedName !== undefined) {
+        return {
+          ...option,
+          isSelected: optionName === disabledSelectedName,
+        }
+      }
+
+      if (isDisabled === true) {
+        return option
+      }
+
+      if (optionName !== name) {
+        return {
+          ...option,
+          isSelected: false,
+        }
+      }
+
+      return {
+        ...option,
+        isSelected: this.enableUnselect ? !option.isSelected : true,
+      }
+    })
+    await this.updateInternalValue(updatedInternalValue)
+  }
+}

package/src/form/inputor-controller/text.ts

@@ -0,0 +1,82 @@
+import type { BaseInputorContext, BaseInputorControllerOptions, BaseInputorSchema, InputorControllerInitializeHooks } from "./base.ts"
+import { BaseInputorController } from "./base.ts"
+
+export const TEXT_INPUTOR_TYPE_NAME = "text" as const
+export type TextInputorTypeName = typeof TEXT_INPUTOR_TYPE_NAME
+
+export type TextInputorExternalValue = string | undefined
+export type TextInputorInternalValue = string | undefined
+export interface TextInputorSchema extends BaseInputorSchema<TextInputorExternalValue> {
+  inputorTypeName: TextInputorTypeName
+  minLength?: number | undefined
+  maxLength?: number | undefined
+}
+export interface TextInputorContext extends BaseInputorContext<TextInputorExternalValue, TextInputorInternalValue> {
+}
+
+export interface TextInputorControllerOptions extends BaseInputorControllerOptions<
+  TextInputorExternalValue,
+  TextInputorSchema
+> {
+  minLength?: number | undefined
+  maxLength?: number | undefined
+}
+export class TextInputorController extends BaseInputorController<
+  TextInputorExternalValue,
+  TextInputorInternalValue,
+  TextInputorSchema,
+  TextInputorContext
+> {
+  declare schemaType: TextInputorSchema
+  declare optionsType: TextInputorControllerOptions
+  declare constructorType: typeof TextInputorController
+
+  static inputorTypeName: TextInputorTypeName = TEXT_INPUTOR_TYPE_NAME
+
+  inputorTypeName: TextInputorTypeName = TEXT_INPUTOR_TYPE_NAME
+  voidExternalValue = undefined
+  voidInternalValue = undefined
+
+  private minLength!: number
+  private maxLength!: number
+
+  constructor(options: TextInputorControllerOptions) {
+    super(options)
+  }
+
+  protected override async initialize(
+    options: TextInputorControllerOptions,
+    hooks?: InputorControllerInitializeHooks,
+  ): Promise<void> {
+    await super.initialize(options, {
+      ...hooks,
+      onSchemaReady: async () => {
+        this.minLength = options.minLength ?? 0
+        this.maxLength = options.maxLength ?? Infinity
+        await hooks?.onSchemaReady?.()
+      },
+    })
+  }
+
+  override async getSchema(): Promise<TextInputorSchema> {
+    return {
+      ...await super.getSchema(),
+      minLength: this.minLength,
+      maxLength: this.maxLength,
+    }
+  }
+
+  protected override async constrainExternalValue(externalValue: TextInputorExternalValue): Promise<TextInputorExternalValue> {
+    if (externalValue === undefined) {
+      return await Promise.resolve(undefined)
+    }
+    return await Promise.resolve(externalValue.slice(0, this.maxLength))
+  }
+
+  protected override async constrainInternalValue(internalValue: TextInputorInternalValue): Promise<TextInputorInternalValue> {
+    if (internalValue === undefined) {
+      return await Promise.resolve(undefined)
+    }
+    return await Promise.resolve(internalValue.slice(0, this.maxLength))
+  }
+}

package/src/http/READMD.md

@@ -0,0 +1 @@
+# Http

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

@@ -0,0 +1,84 @@
+export type ApiCoreHeaderValue = [string, ...string[]] | undefined
+export interface ApiCoreHeaders {
+  [key: string]: ApiCoreHeaderValue
+}
+export interface ApiCoreRequestFormDataEntry {
+  name: string
+  value: string | File
+}
+export type ApiCoreRequestFormData = ApiCoreRequestFormDataEntry[]
+export interface ApiCoreRequestFile {
+  name: string
+  value: File
+}
+export type ApiCoreRequestFiles = ApiCoreRequestFile[]
+export interface ApiCoreStream {
+  write(chunk: Buffer | string, encoding: BufferEncoding): Promise<void>
+  end(): Promise<void>
+}
+
+/**
+ * 参考 WHATWG 语义的稳定内部抽象类，适配不同环境的 HTTP 请求和响应。
+ */
+export abstract class ApiCore {
+  /**
+   * Header names are in lowercase for consistency.
+   */
+  abstract getRequestHeaders(): Promise<ApiCoreHeaders>
+  async getRequestHeader(name: string): Promise<ApiCoreHeaderValue> {
+    const headers = await this.getRequestHeaders()
+    const headerValue = headers[name.toLowerCase()]
+    return headerValue
+  }
+
+  /**
+   * Method names are in uppercase for consistency with the standard HTTP method names.
+   */
+  abstract getRequestMethod(): Promise<string>
+
+  abstract getRequestUrl(): string
+  async getRequestPath(): Promise<string> {
+    const urlInString = this.getRequestUrl()
+    const url = new URL(urlInString)
+    const path = url.pathname
+    return await Promise.resolve(path)
+  }
+  async getRequestSearch(): Promise<string> {
+    const urlInString = this.getRequestUrl()
+    const url = new URL(urlInString)
+    const search = url.search
+    return await Promise.resolve(search)
+  }
+
+  abstract getRequestBodyText(): Promise<string>
+  async getRequestBodyJson(): Promise<unknown> {
+    const bodyText = await this.getRequestBodyText()
+
+    if (bodyText.trim().length === 0) {
+      return {}
+    }
+
+    return JSON.parse(bodyText) as unknown
+  }
+  abstract getRequestBodyFormData(): Promise<ApiCoreRequestFormData>
+  async getRequestFiles(): Promise<ApiCoreRequestFiles> {
+    const formData = await this.getRequestBodyFormData()
+    const files: ApiCoreRequestFiles = []
+
+    for (const entry of formData) {
+      if (entry.value instanceof File) {
+        files.push({
+          name: entry.name,
+          value: entry.value,
+        })
+      }
+    }
+
+    return files
+  }
+
+  abstract text(data: unknown): Promise<void>
+  abstract json(data: unknown): Promise<void>
+  abstract stream(): Promise<ApiCoreStream>
+  abstract error(): Promise<void>
+}

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

@@ -0,0 +1,79 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+
+import type { Logger } from "#Source/log/index.ts"
+
+import type { ApiCore } from "./api-core.ts"
+import type { ErrorResult, SuccessResult } from "./api-result.ts"
+import type { ApiSchemaOptions } from "./api-schema.ts"
+
+export interface ApiHandlerContext<
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends StandardSchemaV1,
+  InputBodySchema extends StandardSchemaV1,
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+> extends ApiSchemaOptions<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema> {
+  inputQuery: StandardSchemaV1.InferOutput<InputQuerySchema>
+  inputBody: StandardSchemaV1.InferOutput<InputBodySchema>
+
+  apiCore: ApiCore
+  logger: Logger
+}
+
+export type AnyApiHandlerContext = ApiHandlerContext<string, "get" | "post", StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1>
+
+export type GetInputQuerySchemaFromApiHandlerContext<Target extends AnyApiHandlerContext> = Target extends ApiHandlerContext<
+  infer _,
+  infer __,
+  infer InputQuerySchema,
+  infer ___,
+  infer ____,
+  infer ______
+> ? InputQuerySchema : never
+export type GetInputBodySchemaFromApiHandlerContext<Target extends AnyApiHandlerContext> = Target extends ApiHandlerContext<
+  infer _,
+  infer __,
+  infer ___,
+  infer InputBodySchema,
+  infer ____,
+  infer ______
+> ? InputBodySchema : never
+export type GetOutputSuccessSchemaFromApiHandlerContext<Target extends AnyApiHandlerContext> = Target extends ApiHandlerContext<
+  infer _,
+  infer __,
+  infer ___,
+  infer ____,
+  infer OutputSuccessSchema,
+  infer ______
+> ? OutputSuccessSchema : never
+export type GetOutputErrorSchemaFromApiHandlerContext<Target extends AnyApiHandlerContext> = Target extends ApiHandlerContext<
+  infer _,
+  infer __,
+  infer ___,
+  infer ____,
+  infer ______,
+  infer OutputErrorSchema
+> ? OutputErrorSchema : never
+
+export type GetInputQueryFromApiHandlerContext<Target extends AnyApiHandlerContext> = StandardSchemaV1.InferOutput<GetInputQuerySchemaFromApiHandlerContext<Target>>
+export type GetInputBodyFromApiHandlerContext<Target extends AnyApiHandlerContext> = StandardSchemaV1.InferOutput<GetInputBodySchemaFromApiHandlerContext<Target>>
+export type GetOutputSuccessFromApiHandlerContext<Target extends AnyApiHandlerContext> = StandardSchemaV1.InferOutput<GetOutputSuccessSchemaFromApiHandlerContext<Target>>
+export type GetOutputErrorFromApiHandlerContext<Target extends AnyApiHandlerContext> = StandardSchemaV1.InferOutput<GetOutputErrorSchemaFromApiHandlerContext<Target>>
+export type GetOutputFromApiHandlerContext<Target extends AnyApiHandlerContext> = GetOutputSuccessFromApiHandlerContext<Target> | GetOutputErrorFromApiHandlerContext<Target>
+
+export type ApiHandlerResult<
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+> = SuccessResult<StandardSchemaV1.InferOutput<OutputSuccessSchema>> | ErrorResult<StandardSchemaV1.InferOutput<OutputErrorSchema>>
+
+export type ApiHandler<
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends StandardSchemaV1,
+  InputBodySchema extends StandardSchemaV1,
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+> = (
+  context: ApiHandlerContext<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>
+) => Promise<ApiHandlerResult<OutputSuccessSchema, OutputErrorSchema>>

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

@@ -0,0 +1,47 @@
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/logger.ts"
+import { Logger } from "#Source/log/logger.ts"
+
+import type { ApiCore } from "./api-core.ts"
+
+export type ApiCoreHandler = (apiCore: ApiCore) => void | Promise<void>
+export interface ApiHostStartResult {
+  urlList: string[]
+}
+
+export interface ApiHostOptions extends LoggerFriendlyOptions {
+  port: number
+}
+export abstract class ApiHost<Server> implements LoggerFriendly {
+  protected readonly options: ApiHostOptions
+
+  readonly logger: Logger
+  protected server: Server | undefined
+
+  constructor(options: ApiHostOptions) {
+    this.options = options
+
+    this.logger = Logger.fromOptions(options).setDefaultName("ApiHost")
+    this.server = undefined
+  }
+
+  safeGetServer(): Server {
+    if (this.server === undefined) {
+      throw new Error("Server is not running.")
+    }
+    return this.server
+  }
+
+  isRunning(): boolean {
+    if (this.server === undefined) {
+      return false
+    }
+    return true
+  }
+
+  abstract attachApiCoreHandler(apiCoreHandler: ApiCoreHandler): void
+  abstract start(): Promise<ApiHostStartResult>
+  abstract close(): Promise<void>
+}
+
+// oxlint-disable-next-line typescript/no-explicit-any
+export type AnyApiHost = ApiHost<any>

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

@@ -0,0 +1,56 @@
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import { Logger } from "#Source/log/index.ts"
+
+import type { ApiCore } from "./api-core.ts"
+
+export interface ResultOptions<_T> extends LoggerFriendlyOptions {
+}
+/**
+ * {@link Api} 的处理器无法获得 Request 和 Response 对象，它不应该直接返回数据给前端，而应该通过
+ * {@link SuccessResult} 或 {@link ErrorResult} 定义自己想要返回什么，然后 {@link ApiServer} 会
+ * 负责执行返回逻辑，将结果返回给前端，这样做既可以使 Api 的核心逻辑更纯粹，也可以保证所有的接口始终
+ * 给前端返回一致的数据结构。
+ */
+export abstract class Result<T> implements LoggerFriendly {
+  protected __PhantomType__?: T
+
+  protected options: ResultOptions<T>
+  readonly logger: Logger
+
+  constructor(options: ResultOptions<T>) {
+    this.options = options
+    this.logger = Logger.fromOptions(options).setDefaultName("Result")
+  }
+
+  abstract handle(apiCore: ApiCore): Promise<void>
+}
+
+// ======================
+
+export interface SuccessResultOptions<T> extends ResultOptions<T> {
+}
+export abstract class SuccessResult<T> extends Result<T> {
+  protected __SuccessResultPhantomType__ = true
+
+  protected declare options: SuccessResultOptions<T>
+
+  constructor(options: SuccessResultOptions<T>) {
+    super(options)
+    this.logger.setDefaultName("SuccessResult")
+  }
+}
+
+// ======================
+
+export interface ErrorResultOptions<T> extends ResultOptions<T> {
+}
+export abstract class ErrorResult<T> extends Result<T> {
+  protected __ErrorResultPhantomType__ = true
+
+  protected declare options: ErrorResultOptions<T>
+
+  constructor(options: ErrorResultOptions<T>) {
+    super(options)
+    this.logger.setDefaultName("ErrorResult")
+  }
+}

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

@@ -0,0 +1,154 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+
+export interface ApiSchemaOptions<
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends StandardSchemaV1,
+  InputBodySchema extends StandardSchemaV1,
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+> {
+  path: Path
+  method: Method
+  inputQuerySchema: InputQuerySchema
+  inputBodySchema: InputBodySchema
+  outputSuccessSchema: OutputSuccessSchema
+  outputErrorSchema: OutputErrorSchema
+}
+/**
+ * 每一个请求都由一个且仅由一个接口（Api）处理。每个 Api 在实现之前需要对其进行描述，
+ * 描述中包含此接口处理的路径（Path）、方法（Method）、query 输入的数据形状（InputQuerySchema）、
+ * body 输入的数据形状（InputBodySchema）、成功输出的数据形状（OutputSuccessSchema）和错误输出的数据形状
+ * （OutputErrorSchema）等，这些描述共同构成 ApiSchema。
+ *
+ * 具体来说：
+ * - path：不能有通配符, 必须是完整的, 具体的路径。
+ * - method：暂时只支持 get 和 post。
+ * - inputQuerySchema：描述接口 query 输入的数据形状。
+ * - inputBodySchema：描述接口 body 输入的数据形状。
+ * - outputSuccessSchema：描述接口成功输出的数据形状。
+ * - outputErrorSchema：描述接口失败输出的数据形状。
+ *
+ * ApiSchema 的主要用途是定义接口的类型，将接口的类型和实现分开，提高代码的可读性和
+ * 可维护性的同时让我们能够将接口类型独立导出给前端。
+ */
+export class ApiSchema<
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends StandardSchemaV1,
+  InputBodySchema extends StandardSchemaV1,
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+> {
+  protected __PathPhantomType__?: Path
+  protected __MethodPhantomType__?: Method
+  protected __InputQuerySchemaPhantomType__?: InputQuerySchema
+  protected __InputBodySchemaPhantomType__?: InputBodySchema
+  protected __OutputSuccessSchemaPhantomType__?: OutputSuccessSchema
+  protected __OutputErrorSchemaPhantomType__?: OutputErrorSchema
+
+  private readonly path: Path
+  private readonly method: Method
+  private readonly inputQuerySchema: InputQuerySchema
+  private readonly inputBodySchema: InputBodySchema
+  private readonly outputSuccessSchema: OutputSuccessSchema
+  private readonly outputErrorSchema: OutputErrorSchema
+
+  constructor(options: ApiSchemaOptions<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>) {
+    this.path = options.path
+    this.method = options.method
+    this.inputQuerySchema = options.inputQuerySchema
+    this.inputBodySchema = options.inputBodySchema
+    this.outputSuccessSchema = options.outputSuccessSchema
+    this.outputErrorSchema = options.outputErrorSchema
+  }
+
+  getApiSchemaOptions(): ApiSchemaOptions<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema> {
+    return {
+      path: this.path,
+      method: this.method,
+      inputQuerySchema: this.inputQuerySchema,
+      inputBodySchema: this.inputBodySchema,
+      outputSuccessSchema: this.outputSuccessSchema,
+      outputErrorSchema: this.outputErrorSchema,
+    }
+  }
+
+  getPath(): Path {
+    return this.path
+  }
+
+  getMethod(): Method {
+    return this.method
+  }
+
+  getInputQuerySchema(): InputQuerySchema {
+    return this.inputQuerySchema
+  }
+
+  getInputBodySchema(): InputBodySchema {
+    return this.inputBodySchema
+  }
+
+  getOutputSuccessSchema(): OutputSuccessSchema {
+    return this.outputSuccessSchema
+  }
+
+  getOutputErrorSchema(): OutputErrorSchema {
+    return this.outputErrorSchema
+  }
+}
+
+export const createApiSchema = <
+  Path extends string,
+  Method extends "get" | "post",
+  InputQuerySchema extends StandardSchemaV1,
+  InputBodySchema extends StandardSchemaV1,
+  OutputSuccessSchema extends StandardSchemaV1,
+  OutputErrorSchema extends StandardSchemaV1,
+>(
+  options: ApiSchemaOptions<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema>
+): ApiSchema<Path, Method, InputQuerySchema, InputBodySchema, OutputSuccessSchema, OutputErrorSchema> => {
+  return new ApiSchema(options)
+}
+
+export type AnyApiSchema = ApiSchema<string, "get" | "post", StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1>
+
+export type GetInputQuerySchemaFromApiSchema<Target extends AnyApiSchema> = Target extends ApiSchema<
+  infer _,
+  infer __,
+  infer InputQuerySchema,
+  infer ___,
+  infer ____,
+  infer ______
+> ? InputQuerySchema : never
+export type GetInputBodySchemaFromApiSchema<Target extends AnyApiSchema> = Target extends ApiSchema<
+  infer _,
+  infer __,
+  infer ___,
+  infer InputBodySchema,
+  infer ____,
+  infer ______
+> ? InputBodySchema : never
+export type GetOutputSuccessSchemaFromApiSchema<Target extends AnyApiSchema> = Target extends ApiSchema<
+  infer _,
+  infer __,
+  infer ___,
+  infer ____,
+  infer OutputSuccessSchema,
+  infer ______
+> ? OutputSuccessSchema : never
+export type GetOutputErrorSchemaFromApiSchema<Target extends AnyApiSchema> = Target extends ApiSchema<
+  infer _,
+  infer __,
+  infer ___,
+  infer ____,
+  infer _____,
+  infer OutputErrorSchema
+> ? OutputErrorSchema : never
+
+export type GetInputQueryFromApiSchema<Target extends AnyApiSchema> = StandardSchemaV1.InferOutput<GetInputQuerySchemaFromApiSchema<Target>>
+export type GetInputBodyFromApiSchema<Target extends AnyApiSchema> = StandardSchemaV1.InferOutput<GetInputBodySchemaFromApiSchema<Target>>
+export type GetOutputSuccessFromApiSchema<Target extends AnyApiSchema> = StandardSchemaV1.InferOutput<GetOutputSuccessSchemaFromApiSchema<Target>>
+export type GetOutputErrorFromApiSchema<Target extends AnyApiSchema> = StandardSchemaV1.InferOutput<GetOutputErrorSchemaFromApiSchema<Target>>
+export type GetOutputFromApiSchema<Target extends AnyApiSchema> = GetOutputSuccessFromApiSchema<Target> | GetOutputErrorFromApiSchema<Target>