@planet-matrix/mobius-model 0.5.0 → 0.9.0

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

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto"
+import fs, { existsSync, mkdirSync } from "node:fs"
+import path from "node:path"
+import ts from "typescript"
+
+import { getGlobalLogger } from "#Source/log/index.ts"
+
+import { getCalcCode } from "./calc-code.ts"
+
+export interface GenerateApiTypeOptions {
+  importFrom: string
+  /**
+   * Path to tsconfig.json file.
+   */
+  tsconfigFilePath: string
+  /**
+   * Path to Api folder.
+   */
+  apiFolderPath: string
+  /**
+   * Path to output file.
+   */
+  outputFilePath: string
+}
+const toAbsolutePath = (options: GenerateApiTypeOptions): GenerateApiTypeOptions => {
+  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 generateApiType = (options: GenerateApiTypeOptions): void => {
+  const {
+    importFrom,
+    tsconfigFilePath,
+    apiFolderPath,
+    outputFilePath,
+  } = toAbsolutePath(options)
+  const logger = getGlobalLogger()
+
+  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("成功读取项目...")
+
+  const allSourceFiles = project.getSourceFiles()
+  const apiSourceFiles = 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))
+  })
+  logger.debug(`找到 ${apiSourceFiles.length} 个接口...`)
+
+  // 为每一个接口文件生成一个虚拟计算文件
+  const apiTypeCalcFileNames = apiSourceFiles.map(sourceFile => sourceFile.fileName.replace("type.ts", `type-calculate-${randomUUID()}.ts`))
+  const calcCode = getCalcCode({ importFrom })
+  const apiTypeCalcFiles = apiTypeCalcFileNames.map((filename) => {
+    return {
+      name: filename,
+      sourceFile: ts.createSourceFile(filename, calcCode, ts.ScriptTarget.Latest),
+    }
+  })
+  logger.debug("成功生成虚拟计算文件...")
+
+  const newProject = ts.createProgram({
+    rootNames: [...parsedTsconfig.fileNames, ...apiTypeCalcFileNames],
+    options: parsedTsconfig.options,
+    host: {
+      ...projectHost,
+      getSourceFile: (filename) => {
+        const apiTypeCalcSourceFile = apiTypeCalcFiles.find(apiTypeCalcSourceFile => apiTypeCalcSourceFile.name === filename)
+        if (apiTypeCalcSourceFile !== undefined) {
+          return apiTypeCalcSourceFile.sourceFile
+        }
+        return project.getSourceFile(filename)
+      },
+    },
+    oldProgram: project,
+  })
+  logger.debug("成功生成虚拟项目...")
+
+  const check = newProject.getTypeChecker()
+  logger.debug("成功生成虚拟项目类型检查器...")
+
+  const result: string[] = []
+  apiSourceFiles.forEach((apiSourceFile, index) => {
+    logger.info(`处理（${index + 1} / ${apiSourceFiles.length}）：${apiSourceFile.fileName}`)
+
+    const apiCalcSourceFile = apiTypeCalcFiles[index]?.sourceFile
+    if (apiCalcSourceFile === undefined) {
+      throw new Error("非预期的数组越界")
+    }
+
+    for (const node of apiCalcSourceFile.statements) {
+      if (ts.isExportAssignment(node) && node.isExportEquals === undefined) {
+        const apiType = check.getTypeAtLocation(node.expression)
+        const typeString = check.typeToString(apiType, undefined, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope)
+        result.push(typeString)
+      }
+    }
+  })
+  logger.debug("成功处理所有接口...")
+
+  const outputPathAbs = path.resolve(outputFilePath)
+  const outDir = path.dirname(outputPathAbs)
+
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true })
+  }
+
+  fs.writeFileSync(outputPathAbs, `export type ApiType = [${result.join(",")}]\n`)
+  logger.debug(`生成成功：${outputPathAbs}`)
+}

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

@@ -0,0 +1,2 @@
+export * from "./calc-code.ts"
+export * from "./gen-api-type.ts"

package/src/http/bin/index.ts

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

package/src/http/index.ts

@@ -0,0 +1,3 @@
+export * from "./api/index.ts"
+export * from "./api-adapter/index.ts"
+export * from "./bin/index.ts"

package/src/huawei/README.md

@@ -0,0 +1 @@
+# Huawei

package/src/huawei/index.ts

@@ -0,0 +1,2 @@
+export * from "./moderation/index.ts"
+export * from "./obs/index.ts"

package/src/huawei/moderation/index.ts

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

package/src/huawei/moderation/moderation.ts

@@ -0,0 +1,355 @@
+import { fetch } from "undici"
+import { type } from "arktype"
+
+import type { LoggerFriendly, LoggerFriendlyOptions } from "#Source/log/index.ts"
+import { Logger } from "#Source/log/index.ts"
+
+type TextEventType =
+  | "nickname" // 昵称
+  | "title" // 标题
+  | "article" // 帖子
+  | "comment" // 评论
+  | "barrage" // 弹幕
+  | "search" // 搜索栏
+  | "profile" // 个人简介
+type ImageEventType =
+  | "head_image" // 头像
+  | "album" // 相册
+  | "dynamic" // 动态
+  | "article" // 帖子
+  | "comment" // 评论
+  | "room_cover" // 房间封面
+  | "group_message" // 群聊图片
+  | "message" // 私聊图片
+  | "product" // 商品图片
+type ImageCategories =
+  | "terrorism" // 暴恐元素的检测
+  | "porn" // 涉黄元素的检测
+  | "image_text" // 广告图文的检测
+const SUGGESTION_TYPE = {
+  block: "block", // 包含敏感信息，不通过
+  pass: "pass", // 不包含敏感信息，通过
+  review: "review", // 需要人工复检
+} as const
+type SuggestionType = typeof SUGGESTION_TYPE[keyof typeof SUGGESTION_TYPE]
+const suggestionTypeSchema = type.or("'block'", "'pass'", "'review'")
+
+const textModerationResponseSchema = type({
+  result: type({
+    suggestion: suggestionTypeSchema,
+  }),
+})
+export interface ModerationTextOptions {
+  input: string
+  eventType: TextEventType
+}
+export interface ModerationTextResult {
+  suggestion: SuggestionType
+}
+const imageModerationResponseSchema = type({
+  result: type({
+    suggestion: suggestionTypeSchema,
+  }),
+})
+export interface ModerationImageOptions {
+  mode: "base64" | "url"
+  input: string
+  eventType: ImageEventType
+  categories: ImageCategories[]
+}
+export interface ModerationImageResult {
+  suggestion: SuggestionType
+}
+
+export interface ModerationOptions extends LoggerFriendlyOptions {
+  userName: string
+  userPwd: string
+  domainName: string
+  projectName: string
+  projectId: string
+  endpoint: string
+  /**
+   * token 有效期，单位：毫秒，默认 11 小时
+   */
+  tokenValidTime?: number | undefined
+}
+interface ResolvedModerationOptions {
+  userName: string
+  userPwd: string
+  domainName: string
+  projectName: string
+  projectId: string
+  endpoint: string
+  tokenValidTime: number
+}
+export class Moderation implements LoggerFriendly {
+  readonly options: ResolvedModerationOptions
+
+  readonly logger: Logger
+
+  protected tokenGetTime: number | null = null
+  protected token: string | null = null
+
+  constructor(options: ModerationOptions) {
+    this.options = {
+      ...options,
+      // token 有效期 12 小时，保险起见，我们超过 11 小时就重写获取一次，以免调用到一半忽然失效
+      // 请求新 token 并不会造成旧 token 失效，所以想象中的问题不会发生
+      tokenValidTime: options.tokenValidTime ?? (11 * 60 * 60 * 1_000),
+    }
+
+    this.logger = Logger.fromOptions(options).setDefaultName("Moderation")
+  }
+
+  /**
+   * {@link https://support.huaweicloud.com/api-moderation/moderation_03_0003.html}
+   * {@link https://support.huaweicloud.com/api-iam/iam_30_0001.html}
+   */
+  protected async getNewToken(): Promise<string> {
+    const {
+      userName,
+      userPwd,
+      domainName,
+      projectName,
+    } = this.options
+    const logger = this.logger
+
+    try {
+      logger.log("准备获取 token...")
+
+      const response = await fetch(
+        `https://iam.${projectName}.myhuaweicloud.com/v3/auth/tokens`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            auth: {
+              identity: {
+                methods: ["password"],
+                password: {
+                  user: {
+                    name: userName,
+                    password: userPwd,
+                    domain: {
+                      name: domainName,
+                    },
+                  },
+                },
+              },
+              scope: {
+                project: {
+                  name: projectName,
+                },
+              },
+            },
+          }),
+        }
+      )
+
+      const responseText = await response.text()
+      const responseBody = responseText === ""
+        ? null
+        : (() => {
+          try {
+            return JSON.parse(responseText) as unknown
+          }
+          catch {
+            return responseText
+          }
+        })()
+      const errorMessage = typeof responseBody === "string"
+        ? responseBody
+        : (() => {
+          try {
+            return JSON.stringify(responseBody)
+          }
+          catch {
+            return String(responseBody)
+          }
+        })()
+
+      if (response.ok === false) {
+        throw new Error(errorMessage)
+      }
+
+      const token = response.headers.get("x-subject-token")
+      if (token === null || token === undefined) {
+        throw new Error(errorMessage)
+      }
+
+      logger.log("获取 token 成功")
+      this.token = token
+      this.tokenGetTime = Date.now()
+      return token
+    } catch (exception) {
+      logger.error(`获取 toekn 失败：${String(exception)}`)
+      throw exception
+    }
+  }
+
+  protected async getToken(): Promise<string> {
+    const token = this.token
+    const tokenGetTime = this.tokenGetTime
+    const { tokenValidTime } = this.options
+
+    if (
+      token === null
+      || tokenGetTime === null
+      || tokenGetTime + tokenValidTime < Date.now()
+    ) {
+      return await this.getNewToken()
+    } else {
+      return await Promise.resolve(token)
+    }
+  }
+
+  /**
+   * @see {@link https://support.huaweicloud.com/api-moderation/moderation_03_0069.html}
+   */
+  async text(
+    options: ModerationTextOptions
+  ): Promise<ModerationTextResult> {
+    const { input, eventType } = options
+    const { endpoint, projectId } = this.options
+    const logger = this.logger
+
+    // empty string is always safe
+    if (input === "") {
+      return { suggestion: "pass" }
+    }
+
+    try {
+      logger.log(`开始调用 text 检查，输入：${input}，类型：${eventType}`)
+
+      const token = await this.getToken()
+      const responseRaw = await fetch(
+        `https://${endpoint}/v3/${projectId}/moderation/text`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Auth-Token": token,
+          },
+          body: JSON.stringify({
+            event_type: eventType,
+            data: {
+              language: "zh",
+              text: input,
+            },
+            glossary_names: [],
+            white_glossary_names: [],
+            categories: ["terrorism", "porn", "ban", "abuse"],
+          }),
+        }
+      )
+      const responseText = await responseRaw.text()
+      const response = responseText === ""
+        ? null
+        : (() => {
+          try {
+            return JSON.parse(responseText) as unknown
+          }
+          catch {
+            return responseText
+          }
+        })()
+
+      if (responseRaw.ok === false) {
+        throw new Error(typeof response === "string" ? response : JSON.stringify(response))
+      }
+
+      const validateResult = await textModerationResponseSchema["~standard"].validate(response)
+      if (validateResult.issues !== undefined) {
+        logger.error(`非预期的返回结果：${JSON.stringify(response)}`)
+        throw new Error("非预期的返回结果")
+      }
+
+      logger.log(`调用成功：${JSON.stringify(validateResult)}`)
+      return validateResult.value.result
+    }
+    catch (exception) {
+      logger.error(`调用失败：${String(exception)}`)
+      throw exception
+    }
+  }
+
+  /**
+   * @see {@link https://support.huaweicloud.com/api-moderation/moderation_03_0086.html}
+   */
+  async image(
+    options: ModerationImageOptions
+  ): Promise<ModerationImageResult> {
+    const { mode, input, eventType, categories } = options
+    const { endpoint, projectId } = this.options
+    const logger = this.logger
+
+    try {
+      logger.log(`开始调用 image 检查，输入：${input}，类型：${eventType}`)
+
+      const token = await this.getToken()
+
+      interface argType {
+        event_type: ImageEventType
+        categories: ImageCategories[]
+        image?: string | undefined
+        url?: string | undefined
+      }
+      const arg: argType = {
+        event_type: eventType,
+        categories,
+        image: mode === "base64" ? input : undefined,
+        url: mode === "url" ? input : undefined,
+      }
+
+      if (mode === "base64") {
+        arg.image = input
+      }
+      else if (mode === "url") {
+        arg.url = input
+      }
+      else {
+        throw new Error("意外的 mode")
+      }
+
+      const responseRaw = await fetch(
+        `https://${endpoint}/v3/${projectId}/moderation/image`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Auth-Token": token,
+          },
+          body: JSON.stringify(arg),
+        }
+      )
+      const responseText = await responseRaw.text()
+      const response = responseText === ""
+        ? null
+        : (() => {
+          try {
+            return JSON.parse(responseText) as unknown
+          }
+          catch {
+            return responseText
+          }
+        })()
+
+      if (responseRaw.ok === false) {
+        throw new Error(typeof response === "string" ? response : JSON.stringify(response))
+      }
+
+      const validateResult = await imageModerationResponseSchema["~standard"].validate(response)
+      if (validateResult.issues !== undefined) {
+        logger.error(`非预期的返回结果：${JSON.stringify(response)}`)
+        throw new Error("非预期的返回结果")
+      }
+
+      logger.log(`调用成功：${JSON.stringify(validateResult.value)}`)
+      return validateResult.value.result
+    }
+    catch (exception) {
+      logger.error(`调用失败：${String(exception)}`)
+      throw exception
+    }
+  }
+}

package/src/huawei/obs/esdk-obs-nodejs.d.ts

@@ -0,0 +1,87 @@
+declare module "esdk-obs-nodejs" {
+  import type { Readable } from "node:stream"
+
+  interface CommonMsg {
+    Status: number
+    Code: string
+    Message: string
+    HostId: string
+    RequestId: string
+    Id2: string
+    Indicator: string
+  }
+
+  type ObsResult<InterfaceResult> = Promise<{
+    CommonMsg: CommonMsg
+    InterfaceResult: InterfaceResult
+  }>
+
+  export interface GetBucketMetadataOptions {
+    Bucket: string
+  }
+  export interface GetBucketMetadataInterfaceResult {
+    RequestId: string
+    StorageClass: string
+    Location: string
+    ObsVersion: string
+    AllowOrigin: string
+    AllowHeader: string
+    AllowMethod: string
+    ExposeHeader: string
+    MaxAgeSeconds: string
+  }
+  export type GetBucketMetadataResult = ObsResult<GetBucketMetadataInterfaceResult>
+
+  export interface PutObjectOptions {
+    Bucket: string
+    Key: string
+    Body: string | Readable
+    ContentType?: string | undefined
+    ProgressCallback?: ((count: number, objectTotalSize: number, time: number) => void) | undefined
+  }
+  export interface PutObjectInterfaceResult {
+    RequestId: string
+    ETag: string
+    VersionId: string
+    StorageClass: string
+    SseKms: string
+    SseKmsKey: string
+    SseC: string
+    SseCKeyMd5: string
+  }
+  export type PutObjectResult = ObsResult<PutObjectInterfaceResult>
+
+  export type DeleteObjectOptions = {
+    Bucket: string
+    Key: string
+    VersionId?: string | undefined
+    ProgressCallback?: ((count: number, objectTotalSize: number, time: number) => void) | undefined
+  }
+  export type DeleteObjectInterfaceResult = {
+    RequestId: string
+    DeleteMarker: string
+    VersionId: string
+  }
+  export type DeleteObjectResult = ObsResult<DeleteObjectInterfaceResult>
+
+  export interface ObsClientOptions {
+    access_key_id: string
+    secret_access_key: string
+    server: string
+  }
+  export class ObsClient {
+    constructor(options: ObsClientOptions)
+
+    GetBucketMetadata: (
+      options: GetBucketMetadataOptions
+    ) => GetBucketMetadataResult
+
+    putObject: (
+      options: PutObjectOptions
+    ) => PutObjectResult
+
+    deleteObject: (
+      options: DeleteObjectOptions
+    ) => DeleteObjectResult
+  }
+}

package/src/huawei/obs/index.ts

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

package/src/huawei/obs/obs.ts

@@ -0,0 +1,42 @@
+import type { DeleteObjectOptions, DeleteObjectResult, PutObjectOptions, PutObjectResult } from "esdk-obs-nodejs"
+import { ObsClient } from "esdk-obs-nodejs"
+
+export interface ObsOptions {
+  accessKeyId: string
+  secretAccessKey: string
+  server: string
+}
+/**
+ * @see {@link https://www.huaweicloud.com/product/obs.html | 华为云对象存储服务}
+ */
+export class Obs {
+  protected obsClient: ObsClient
+
+  constructor(options: ObsOptions) {
+    this.obsClient = new ObsClient({
+      access_key_id: options.accessKeyId,
+      secret_access_key: options.secretAccessKey,
+      server: options.server
+    })
+  }
+
+  async putObject(
+    options: PutObjectOptions
+  ): Promise<PutObjectResult> {
+    const result = await this.obsClient.putObject(options)
+    if (result.CommonMsg.Status >= 300) {
+      throw new Error(result.CommonMsg.Message)
+    }
+    return result
+  }
+
+  async deleteObject(
+    options: DeleteObjectOptions
+  ): Promise<DeleteObjectResult> {
+    const result = await this.obsClient.deleteObject(options)
+    if (result.CommonMsg.Status >= 300) {
+      throw new Error(result.CommonMsg.Message)
+    }
+    return result
+  }
+}