@planet-matrix/mobius-model 0.9.0 → 0.10.1

package/src/result/generator.ts

@@ -0,0 +1,168 @@
+import { mustFixError } from "#Source/exception/error/must-fix.ts"
+
+import type { AnyEither, GetLeft, GetRight } from "./either.ts"
+import { Either } from "./either.ts"
+
+export type EitherSyncGenerator<Yield extends AnyEither, Return extends AnyEither>
+  = Generator<Yield, Return, unknown>
+export type EitherAsyncGenerator<Yield extends AnyEither, Return extends AnyEither>
+  = AsyncGenerator<Yield, Return, unknown>
+
+export type GetEitherGeneratorResult<Yield extends AnyEither, Return extends AnyEither> = Either<
+  GetLeft<Yield> | GetLeft<Return>,
+  GetRight<Return>
+>
+
+export const runSyncGenerator = <Yield extends AnyEither, Return extends AnyEither>(
+  generator: EitherSyncGenerator<Yield, Return>,
+): GetEitherGeneratorResult<Yield, Return> => {
+  let iteratorResult: IteratorResult<Yield, Return>
+  try {
+    iteratorResult = generator.next()
+  } catch (exception) {
+    throw mustFixError("Generator threw an exception", { cause: exception })
+  }
+
+  if (Either.isEither(iteratorResult.value) === false) {
+    throw mustFixError("Generator yielded a non-Either value", { cause: iteratorResult.value })
+  }
+
+  if (iteratorResult.done === false) {
+    try {
+      generator.return?.(undefined as never)
+    } catch (exception) {
+      throw mustFixError("Generator threw an exception during cleanup", { cause: exception })
+    }
+  }
+
+  return iteratorResult.value
+}
+
+export const runAsyncGenerator = async <Yield extends AnyEither, Return extends AnyEither>(
+  generator: EitherAsyncGenerator<Yield, Return>,
+): Promise<GetEitherGeneratorResult<Yield, Return>> => {
+  let iteratorResult: IteratorResult<Yield, Return>
+  try {
+    iteratorResult = await generator.next()
+  } catch (exception) {
+    throw mustFixError("Generator threw an exception", { cause: exception })
+  }
+
+  if (Either.isEither(iteratorResult.value) === false) {
+    throw mustFixError("Generator yielded a non-Either value", { cause: iteratorResult.value })
+  }
+
+  if (iteratorResult.done === false) {
+    try {
+      await generator.return?.(undefined as never)
+    } catch (exception) {
+      throw mustFixError("Generator threw an exception during cleanup", { cause: exception })
+    }
+  }
+
+  return iteratorResult.value
+}
+
+export interface GenSync {
+  <Yield extends AnyEither, Return extends AnyEither>(
+    generatorFunction: () => EitherSyncGenerator<Yield, Return>,
+  ): GetEitherGeneratorResult<Yield, Return>
+  <Yield extends AnyEither, Return extends AnyEither, This>(
+    generatorFunction: (this: This) => EitherSyncGenerator<Yield, Return>,
+    thisArg: This,
+  ): GetEitherGeneratorResult<Yield, Return>
+}
+export const genSync: GenSync = <Yield extends AnyEither, Return extends AnyEither, This>(
+  generatorFunction:
+    | (() => EitherSyncGenerator<Yield, Return>)
+    | ((this: This) => EitherSyncGenerator<Yield, Return>),
+  thisArg?:
+    | This
+    | undefined,
+): GetEitherGeneratorResult<Yield, Return> => {
+  let generator: EitherSyncGenerator<Yield, Return>
+  if (thisArg !== undefined) {
+    generator = (
+      generatorFunction as ((this: This) => EitherSyncGenerator<Yield, Return>)
+    ).call(thisArg)
+  } else {
+    generator = (
+      generatorFunction as (() => EitherSyncGenerator<Yield, Return>)
+    )()
+  }
+  const result = runSyncGenerator(generator)
+  return result
+}
+
+export interface GenAsync {
+  <Yield extends AnyEither, Return extends AnyEither>(
+    generatorFunction: () => EitherAsyncGenerator<Yield, Return>,
+  ): Promise<GetEitherGeneratorResult<Yield, Return>>
+  <Yield extends AnyEither, Return extends AnyEither, This>(
+    generatorFunction: (this: This) => EitherAsyncGenerator<Yield, Return>,
+    thisArg: This,
+  ): Promise<GetEitherGeneratorResult<Yield, Return>>
+}
+export const genAsync: GenAsync = async <Yield extends AnyEither, Return extends AnyEither, This>(
+  generatorFunction:
+    | (() => EitherAsyncGenerator<Yield, Return>)
+    | ((this: This) => EitherAsyncGenerator<Yield, Return>),
+  thisArg?:
+    | This
+    | undefined,
+): Promise<GetEitherGeneratorResult<Yield, Return>> => {
+  let generator: EitherAsyncGenerator<Yield, Return>
+  if (thisArg !== undefined) {
+    generator = (
+      generatorFunction as ((this: This) => EitherAsyncGenerator<Yield, Return>)
+    ).call(thisArg)
+  } else {
+    generator = (
+      generatorFunction as (() => EitherAsyncGenerator<Yield, Return>)
+    )()
+  }
+  const result = await runAsyncGenerator(generator)
+  return result
+}
+
+export interface Gen extends GenSync, GenAsync {
+}
+export const gen = (<Yield extends AnyEither, Return extends AnyEither, This>(
+  generatorFunction:
+    | (() => EitherSyncGenerator<Yield, Return>)
+    | ((thisArg: This) => EitherSyncGenerator<Yield, Return>)
+    | (() => EitherAsyncGenerator<Yield, Return>)
+    | ((thisArg: This) => EitherAsyncGenerator<Yield, Return>),
+  thisArg?:
+    | This
+    | undefined,
+): (
+    | GetEitherGeneratorResult<Yield, Return>
+    | Promise<GetEitherGeneratorResult<Yield, Return>>
+  ) => {
+  let generator: EitherSyncGenerator<Yield, Return> | EitherAsyncGenerator<Yield, Return>
+  if (thisArg !== undefined) {
+    generator = (generatorFunction as (
+      (this: This) => EitherSyncGenerator<Yield, Return> | EitherAsyncGenerator<Yield, Return>
+    )).call(thisArg)
+  } else {
+    generator = (generatorFunction as (
+      () => EitherSyncGenerator<Yield, Return> | EitherAsyncGenerator<Yield, Return>
+    ))()
+  }
+  if (Symbol.asyncIterator in generator) {
+    return runAsyncGenerator(generator)
+  }
+  if (Symbol.iterator in generator) {
+    return runSyncGenerator(generator)
+  }
+  throw new TypeError("Invalid generator function")
+}) as Gen
+
+export const genAwait = async function* <Left, Right>(
+  promise: Promise<Either<Left, Right>>
+): AsyncGenerator<Either<Left, Right>, Right, unknown> {
+  const either = await promise
+  const result = yield* either
+  return result
+}

package/src/result/index.ts

@@ -1,2 +1,3 @@
 export * from "./either.ts"
+export * from "./generator.ts"
 export * from "./controller.ts"

package/src/route/router/router.ts

@@ -481,7 +481,6 @@ const internalCloneRouteHistoryEntry = (historyEntry: RouteHistoryEntry): RouteH
       return cachedRouteHistoryEntry
     }
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const clonedRouteHistoryEntry = {
       id: sourceHistoryEntry.id,
       from: internalCloneRouteEntry(sourceHistoryEntry.from),

package/src/route/uri/hash.ts

@@ -106,7 +106,6 @@ export type HashUnion = HashStringLoose | HashStringStrict | HashObject
  * ```
  */
 export const neatenHash = (target: string): HashStringStrict => {
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   return target.startsWith("#") ? (target as HashStringStrict) : `#${target}`
 }
 

package/src/route/uri/search.ts

@@ -119,7 +119,6 @@ export type SearchUnion = QueryString | QueryObject | SearchStringLoose | Search
  * ```
  */
 export const neatenSearch = (target: string): SearchStringStrict => {
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   return target.startsWith("?") ? (target as SearchStringStrict) : `?${target}`
 }
 

package/src/service/README.md

@@ -0,0 +1 @@
+# Service

package/src/service/index.ts

@@ -0,0 +1 @@
+export * from "./service.ts"

package/src/service/service.ts

@@ -0,0 +1,110 @@
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import { Logger } from "#Source/log/index.ts"
+import type {
+  Controller,
+  Either,
+  EitherAsyncGenerator,
+  EitherSyncGenerator,
+  GetEitherGeneratorResult,
+  TupleOfEither,
+} from "#Source/result/index.ts"
+import { controllerFromEitherType, eitherToTuple, gen } from "#Source/result/index.ts"
+
+export interface BaseServiceOptions extends LoggerFriendlyOptions { }
+/**
+ * 通过继承此基类实现业务逻辑，与使用函数实现业务逻辑相比，具有以下优势：
+ *
+ * 1. 依赖管理：统一注入所有通用依赖，如 logger 等，避免在每个函数实现中重复声明。
+ * 2. 暂时想不到了。
+ */
+export abstract class BaseService<Options, Left, Right> implements LoggerFriendly {
+  readonly logger: Logger
+  protected controller: Controller<Left, Right>
+
+  constructor(options: BaseServiceOptions) {
+    this.logger = Logger.fromOptions(options).setDefaultName("BaseService")
+    this.controller = controllerFromEitherType<Either<Left, Right>>()
+  }
+
+  protected gen<Yield extends Either<Left, unknown>, Return extends Either<Left, Right>>(
+    generatorFunction:
+      | ((this: this) => EitherSyncGenerator<Yield, Return>),
+  ): GetEitherGeneratorResult<Yield, Return>
+  protected gen<Yield extends Either<Left, unknown>, Return extends Either<Left, Right>>(
+    generatorFunction:
+      | ((this: this) => EitherAsyncGenerator<Yield, Return>),
+  ): Promise<GetEitherGeneratorResult<Yield, Return>>
+  protected gen<Yield extends Either<Left, unknown>, Return extends Either<Left, Right>>(
+    generatorFunction:
+      | ((this: this) => EitherSyncGenerator<Yield, Return>)
+      | ((this: this) => EitherAsyncGenerator<Yield, Return>),
+  ): (
+      | GetEitherGeneratorResult<Yield, Return>
+      | Promise<GetEitherGeneratorResult<Yield, Return>>
+    ) {
+    return gen(generatorFunction as never, this)
+  }
+
+  protected abstract implement(options: Options): Promise<Either<Left, Right>>
+
+  async runToEither(options: Options): Promise<Either<Left, Right>> {
+    return await this.implement(options)
+  }
+
+  async runToTuple(options: Options): Promise<TupleOfEither<Left, Right>> {
+    const result = await this.implement(options)
+    return eitherToTuple(result)
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyServiceInstance = BaseService<any, any, any>
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyServiceConstructor = new (...args: any[]) => AnyServiceInstance
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type GetServiceInstance<T extends AnyServiceConstructor> = T extends new (...args: any[]) => infer Instance ? Instance : never
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type GetServiceConstructorOptions<T extends AnyServiceConstructor> = T extends new (options: infer Options, ...args: any[]) => any ? Options : never
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type GetServiceInstanceOptions<T extends AnyServiceConstructor> = GetServiceInstance<T> extends BaseService<infer Options, any, any> ? Options : never
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type GetServiceInstanceLeft<T extends AnyServiceConstructor> = GetServiceInstance<T> extends BaseService<any, infer Left, any> ? Left : never
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type GetServiceInstanceRight<T extends AnyServiceConstructor> = GetServiceInstance<T> extends BaseService<any, any, infer Right> ? Right : never
+
+export const newService = <ServiceConstructor extends AnyServiceConstructor>(
+  ServiceConstructor: ServiceConstructor,
+  constructorOptions: GetServiceConstructorOptions<ServiceConstructor>,
+): GetServiceInstance<ServiceConstructor> => {
+  return new ServiceConstructor(constructorOptions) as GetServiceInstance<ServiceConstructor>
+}
+
+export type RunToEither<ServiceConstructor extends AnyServiceConstructor> = (
+  options: GetServiceInstanceOptions<ServiceConstructor>,
+) => Promise<Either<GetServiceInstanceLeft<ServiceConstructor>, GetServiceInstanceRight<ServiceConstructor>>>
+export const newServiceAndRunToEither = <ServiceConstructor extends AnyServiceConstructor>(
+  ServiceConstructor: ServiceConstructor,
+  constructorOptions: GetServiceConstructorOptions<ServiceConstructor>,
+): RunToEither<ServiceConstructor> => {
+  const service = newService(ServiceConstructor, constructorOptions)
+  const run: RunToEither<ServiceConstructor> = async (options) => {
+    const result = await service.runToEither(options)
+    return result
+  }
+  return run
+}
+
+export type RunToTuple<ServiceConstructor extends AnyServiceConstructor> = (
+  options: GetServiceInstanceOptions<ServiceConstructor>,
+) => Promise<TupleOfEither<GetServiceInstanceLeft<ServiceConstructor>, GetServiceInstanceRight<ServiceConstructor>>>
+export const newServiceAndRunToTuple = <ServiceConstructor extends AnyServiceConstructor>(
+  ServiceConstructor: ServiceConstructor,
+  constructorOptions: GetServiceConstructorOptions<ServiceConstructor>,
+): RunToTuple<ServiceConstructor> => {
+  const service = newService(ServiceConstructor, constructorOptions)
+  const run: RunToTuple<ServiceConstructor> = async (options) => {
+    const result = await service.runToTuple(options)
+    return result
+  }
+  return run
+}

package/src/socket/client/socket-unit.ts

@@ -415,9 +415,7 @@ export class SocketUnit<Message> implements LoggerFriendly {
 
   protected parseMessage(event: MessageEvent): Message | undefined {
     try {
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       const messageString = event.data as string
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       const parsedMessage = JSON.parse(messageString) as Message
       return parsedMessage
     }

package/src/socket/server/socket-unit.ts

@@ -337,7 +337,6 @@ export class SocketUnit<Message> implements LoggerFriendly {
   protected parseMessage(data: RawData): Message | undefined {
     try {
       const messageString = data.toString()
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       const parsedMessage = JSON.parse(messageString) as Message
       return parsedMessage
     }

package/src/tube/helper.ts

@@ -130,7 +130,6 @@ export const readableStreamToTube = <D, E = Error>(
     readableStream,
     onValue: async chunk => await tube.pushData(chunk),
     onDone: async () => await tube.close(),
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     onError: async error => await tube.pushError(error as E),
   })
 

package/src/weixin/official-account/authorization.ts

@@ -43,7 +43,6 @@ export const getAuthAccessToken = async (
       },
     )
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const json = await result.json() as AccessTokenSuccessResponse | AccessTokenErrorResponse
 
     if ("errcode" in json) {
@@ -111,7 +110,6 @@ export const getUserInfo = async (
       },
     )
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const json = await result.json() as UserInfoSuccessResponse | UserInfoErrorResponse
 
     if ("errcode" in json) {

package/src/weixin/official-account/js-api.ts

@@ -41,7 +41,6 @@ export const getJsApiAccessToken = async (
       },
     )
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const json = await result.json() as StableTokenResponse
 
     return {
@@ -88,7 +87,6 @@ export const getJsApiTicket = async (
       },
     )
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const json = await result.json() as JsApiTicketResponse
 
     return {

package/src/weixin/open/oauth2.ts

@@ -63,7 +63,6 @@ export class WeixinOauth2 {
         },
       )
 
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       const json = await result.json() as AccessTokenSuccessResponse | AccessTokenErrorResponse
 
       if ("errcode" in json) {
@@ -117,7 +116,6 @@ export class WeixinOauth2 {
         },
       )
 
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       const json = await result.json() as UserInfoSuccessResponse | UserInfoErrorResponse
 
       if ("errcode" in json) {

package/tests/unit/aio/json.spec.ts

@@ -32,7 +32,6 @@ const createSyncSchema = (
           }
         }
 
-        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
         const record = value as Record<string, unknown>
         if (typeof record["value"] !== "number") {
           return {