@planet-matrix/mobius-model 0.5.0 → 0.9.0

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

@@ -0,0 +1,159 @@
+import { fetch } from "undici"
+
+export interface GetAuthAccessTokenOptions {
+  appId: string
+  appSecret: string
+  code: string
+}
+export interface GetAuthAccessTokenResult {
+  accessToken: string
+  expiresAt: number
+  refreshToken: string
+  openid: string
+  scope: string
+  isSnapshotUser: boolean
+  unionid?: string | undefined
+}
+export const getAuthAccessToken = async (
+  options: GetAuthAccessTokenOptions
+): Promise<GetAuthAccessTokenResult> => {
+  const { appId, appSecret, code } = options
+
+  interface AccessTokenSuccessResponse {
+    access_token: string
+    expires_in: number
+    refresh_token: string
+    openid: string
+    scope: string
+    is_snapshotuser?: 1
+    unionid?: string
+  }
+  interface AccessTokenErrorResponse {
+    errcode: number
+    errmsg: string
+  }
+  const url = `https://api.weixin.qq.com/sns/oauth2/access_token?appid=${appId}&secret=${appSecret}&code=${code}&grant_type=authorization_code`
+
+  try {
+    const now = Date.now()
+    const result = await fetch(
+      url,
+      {
+        method: "get",
+      },
+    )
+
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const json = await result.json() as AccessTokenSuccessResponse | AccessTokenErrorResponse
+
+    if ("errcode" in json) {
+      throw new Error(`${json.errcode}: ${json.errmsg}`)
+    }
+
+    return {
+      accessToken: json.access_token,
+      expiresAt: now + json.expires_in * 1_000,
+      refreshToken: json.refresh_token,
+      openid: json.openid,
+      scope: json.scope,
+      isSnapshotUser: json.is_snapshotuser === 1,
+      unionid: json.unionid,
+    }
+  }
+  catch (exception) {
+    console.error("Error getting access token:", exception)
+    throw exception
+  }
+}
+
+export interface GetUserInfoOptions {
+  accessToken: string
+  openId: string
+}
+export interface GetUserInfoResult {
+  openid: string
+  nickname: string
+  sex: number
+  province: string
+  city: string
+  country: string
+  headimgurl: string
+  privilege: string[]
+  unionid: string
+}
+export const getUserInfo = async (
+  options: GetUserInfoOptions
+): Promise<GetUserInfoResult> => {
+  const { accessToken, openId } = options
+
+  interface UserInfoSuccessResponse {
+    openid: string
+    nickname: string
+    sex: number
+    province: string
+    city: string
+    country: string
+    headimgurl: string
+    privilege: string[]
+    unionid: string
+  }
+  interface UserInfoErrorResponse {
+    errcode: number
+    errmsg: string
+  }
+  const url = `https://api.weixin.qq.com/sns/userinfo?access_token=${accessToken}&openid=${openId}&lang=zh_CN`
+
+  try {
+    const result = await fetch(
+      url,
+      {
+        method: "get",
+      },
+    )
+
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const json = await result.json() as UserInfoSuccessResponse | UserInfoErrorResponse
+
+    if ("errcode" in json) {
+      throw new Error(`${json.errcode}: ${json.errmsg}`)
+    }
+    return json
+  }
+  catch (exception) {
+    console.error("Error getting user info:", exception)
+    throw exception
+  }
+}
+
+export interface WeixinOfficialAccountOauth2Options {
+  appId: string
+  appSecret: string
+}
+/**
+ * @see {@link https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/Wechat_webpage_authorization.html | 微信网页开发 / 网页授权}
+ */
+export class WeixinOfficialAccountOauth2 {
+  private readonly appId: string
+  private readonly appSecret: string
+
+  constructor(options: WeixinOfficialAccountOauth2Options) {
+    const { appId, appSecret } = options
+    this.appId = appId
+    this.appSecret = appSecret
+  }
+
+  async getAccessToken(code: string): Promise<GetAuthAccessTokenResult> {
+    return await getAuthAccessToken({
+      appId: this.appId,
+      appSecret: this.appSecret,
+      code,
+    })
+  }
+
+  async getUserInfo(accessToken: string, openId: string): Promise<GetUserInfoResult> {
+    return await getUserInfo({
+      accessToken,
+      openId,
+    })
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from "./authorization.ts"
+export * from "./js-api.ts"

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

@@ -0,0 +1,134 @@
+import { hash } from "node:crypto"
+
+import { fetch } from "undici"
+
+export interface GetJsApiAccessTokenOptions {
+  appId: string
+  appSecret: string
+}
+export interface GetJsApiAccessTokenResult {
+  accessToken: string
+  /**
+   * in milliseconds
+   */
+  accessTokenExpiresAt: number
+}
+/**
+ * @see {@link https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/getStableAccessToken.html}
+ * @see {@link https://mp.weixin.qq.com/debug | 微信公众平台 - 接口调试工具}
+ */
+export const getJsApiAccessToken = async (
+  options: GetJsApiAccessTokenOptions
+): Promise<GetJsApiAccessTokenResult | undefined> => {
+  const { appId, appSecret } = options
+
+  interface StableTokenResponse {
+    access_token: string
+    expires_in: number
+  }
+  try {
+    const now = Date.now()
+    const result = await fetch(
+      "https://api.weixin.qq.com/cgi-bin/stable_token",
+      {
+        method: "post",
+        body: JSON.stringify({
+          grant_type: "client_credential",
+          appid: appId,
+          secret: appSecret,
+          force_refresh: false,
+        }),
+      },
+    )
+
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const json = await result.json() as StableTokenResponse
+
+    return {
+      accessToken: json.access_token,
+      accessTokenExpiresAt: now + json.expires_in * 1_000,
+    }
+  }
+  catch (exception) {
+    console.error(exception)
+    return undefined
+  }
+}
+
+export interface GetJsApiTicketOptions {
+  accessToken: string
+}
+export interface GetJsApiTicketResult {
+  jsApiTicket: string
+  /**
+   * in milliseconds
+   */
+  expiresAt: number
+}
+/**
+ * @see {@link https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/JS-SDK.html#62 | 附录 1 - JS-SDK 使用权限签名算法}
+ */
+export const getJsApiTicket = async (
+  options: GetJsApiTicketOptions
+): Promise<GetJsApiTicketResult | undefined> => {
+  const { accessToken } = options
+
+  interface JsApiTicketResponse {
+    errcode: number
+    errmsg: string
+    ticket: string
+    expires_in: number
+  }
+  try {
+    const now = Date.now()
+    const result = await fetch(
+      `https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=${accessToken}&type=jsapi`,
+      {
+        method: "get",
+      },
+    )
+
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const json = await result.json() as JsApiTicketResponse
+
+    return {
+      jsApiTicket: json.ticket,
+      expiresAt: now + json.expires_in * 1_000,
+    }
+  }
+  catch (exception) {
+    console.error(exception)
+    return undefined
+  }
+}
+
+export interface SignJsSdkConfigOptions {
+  url: string
+  jsApiTicket: string
+}
+export interface SignJsSdkConfigResult {
+  timestamp: number
+  nonceStr: string
+  signature: string
+}
+/**
+ * @see {@link https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/JS-SDK.html#62 | 签名算法}
+ * @see {@link https://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=jsapisign | 微信公众平台 - 微信 JS 接口签名校验工具}
+ */
+export const signJsSdkConfig = (
+  options: SignJsSdkConfigOptions
+): SignJsSdkConfigResult => {
+  const { url, jsApiTicket } = options
+
+  const nonceStr = Math.random().toString(36).slice(2, 17)
+  const timestamp = Math.floor(Date.now() / 1_000)
+
+  const rawString = `jsapi_ticket=${jsApiTicket}&noncestr=${nonceStr}&timestamp=${timestamp}&url=${url}`
+  const signature = hash("sha1", rawString)
+
+  return {
+    timestamp,
+    nonceStr,
+    signature,
+  }
+}

package/src/weixin/open/index.ts

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

package/src/weixin/open/oauth2.ts

@@ -0,0 +1,133 @@
+import { fetch } from "undici"
+
+export interface WeixinAccessTokenResult {
+  accessToken: string
+  expiresAt: number
+  refreshToken: string
+  openid: string
+  scope: string
+  unionid?: string | undefined
+}
+
+export interface WeixinUserInfoResult {
+  openid: string
+  nickname: string
+  sex: number
+  province: string
+  city: string
+  country: string
+  headimgurl: string
+  privilege: string[]
+  unionid?: string | undefined
+}
+
+export interface WeixinOauth2Options {
+  appId: string
+  appSecret: string
+}
+
+export class WeixinOauth2 {
+  protected options: WeixinOauth2Options
+
+  constructor(options: WeixinOauth2Options) {
+    this.options = options
+  }
+
+  /**
+   * {@link https://developers.weixin.qq.com/doc/oplatform/Website_App/WeChat_Login/Wechat_Login.html | 关于微信快速登录功能的说明}
+   */
+  public async getAccessToken(
+    code: string
+  ): Promise<WeixinAccessTokenResult> {
+    interface AccessTokenSuccessResponse {
+      access_token: string
+      expires_in: number
+      refresh_token: string
+      openid: string
+      scope: string
+      unionid?: string
+    }
+    interface AccessTokenErrorResponse {
+      errcode: number
+      errmsg: string
+    }
+    const { appId, appSecret } = this.options
+    const url = `https://api.weixin.qq.com/sns/oauth2/access_token?appid=${appId}&secret=${appSecret}&code=${code}&grant_type=authorization_code`
+
+    try {
+      const now = Date.now()
+      const result = await fetch(
+        url,
+        {
+          method: "get",
+        },
+      )
+
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+      const json = await result.json() as AccessTokenSuccessResponse | AccessTokenErrorResponse
+
+      if ("errcode" in json) {
+        throw new Error(`${json.errcode}: ${json.errmsg}`)
+      }
+
+      return {
+        accessToken: json.access_token,
+        expiresAt: now + json.expires_in * 1_000,
+        refreshToken: json.refresh_token,
+        openid: json.openid,
+        scope: json.scope,
+        unionid: json.unionid,
+      }
+    }
+    catch (exception) {
+      console.error("Error getting access token:", exception)
+      throw exception
+    }
+  }
+
+  /**
+   * {@link https://developers.weixin.qq.com/doc/oplatform/Website_App/WeChat_Login/Authorized_Interface_Calling_UnionID.html | 获取用户个人信息（UnionID机制）}
+   */
+  public async getUserInfo(
+    accessToken: string,
+    openId: string,
+  ): Promise<WeixinUserInfoResult> {
+    interface UserInfoSuccessResponse {
+      openid: string
+      nickname: string
+      sex: number
+      province: string
+      city: string
+      country: string
+      headimgurl: string
+      privilege: string[]
+      unionid?: string
+    }
+    interface UserInfoErrorResponse {
+      errcode: number
+      errmsg: string
+    }
+    const url = `https://api.weixin.qq.com/sns/userinfo?access_token=${accessToken}&openid=${openId}&lang=zh_CN`
+
+    try {
+      const result = await fetch(
+        url,
+        {
+          method: "get",
+        },
+      )
+
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+      const json = await result.json() as UserInfoSuccessResponse | UserInfoErrorResponse
+
+      if ("errcode" in json) {
+        throw new Error(`${json.errcode}: ${json.errmsg}`)
+      }
+      return json
+    }
+    catch (exception) {
+      console.error("Error getting user info:", exception)
+      throw exception
+    }
+  }
+}

package/tests/unit/abort/abort-manager.spec.ts

@@ -0,0 +1,225 @@
+import { expect, test } from "vitest"
+
+import {
+  ABORT_MANAGER_MODE,
+  AbortManager,
+  all,
+  any,
+  fromAbortFriendlyOptions,
+  fromAbortable,
+  fromWithAbortSignal,
+  getAbortSignal,
+  isAborted,
+} from "#Source/abort/index.ts"
+
+test("getAbortSignal resolves AbortSignal from supported abortables", () => {
+  const abortController = new AbortController()
+  const abortManager = new AbortManager({})
+
+  expect(getAbortSignal(abortController.signal)).toBe(abortController.signal)
+  expect(getAbortSignal(abortController)).toBe(abortController.signal)
+  expect(getAbortSignal(abortManager)).toBe(abortManager.abortSignal)
+})
+
+test("isAborted reflects abort state from abortables", () => {
+  const abortController = new AbortController()
+
+  expect(isAborted(abortController.signal)).toBe(false)
+  expect(isAborted(abortController)).toBe(false)
+
+  abortController.abort("stop")
+
+  expect(isAborted(abortController.signal)).toBe(true)
+  expect(isAborted(abortController)).toBe(true)
+})
+
+test("AbortManager constructor links upstream abortManager from options", () => {
+  const upstream = new AbortManager({})
+  const abortManager = new AbortManager({ abortManager: upstream })
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream.abort("upstream")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.isAborted mirrors internal abortSignal", () => {
+  const abortManager = new AbortManager({})
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  abortManager.abort("done")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.setMode sets mode and supports chaining", () => {
+  const abortManager = new AbortManager({})
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+
+  const returned = abortManager
+    .setMode(ABORT_MANAGER_MODE.ANY)
+    .addUpstreams([upstream1.signal, upstream2.signal])
+
+  expect(returned).toBe(abortManager)
+
+  upstream1.abort("one")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.addUpstreams makes manager abort when upstream condition is met", () => {
+  const abortManager = new AbortManager({})
+  const upstream = new AbortController()
+
+  abortManager.addUpstreams([upstream.signal])
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream.abort("upstream")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.removeUpstreams detaches selected upstreams", () => {
+  const abortManager = new AbortManager({})
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+
+  abortManager
+    .setMode(ABORT_MANAGER_MODE.ANY)
+    .addUpstreams([upstream1.signal, upstream2.signal])
+    .removeUpstreams([upstream1.signal])
+
+  upstream1.abort("ignored")
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream2.abort("active")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.removeAllUpstreams detaches all upstreams", () => {
+  const abortManager = new AbortManager({})
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+
+  abortManager
+    .setMode(ABORT_MANAGER_MODE.ANY)
+    .addUpstreams([upstream1.signal, upstream2.signal])
+    .removeAllUpstreams()
+
+  upstream1.abort("ignored")
+  upstream2.abort("ignored")
+
+  expect(abortManager.isAborted()).toBe(false)
+})
+
+test("AbortManager.tryToAbort evaluates mode conditions", () => {
+  const abortManager = new AbortManager({})
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+
+  abortManager
+    .setMode(ABORT_MANAGER_MODE.ALL)
+    .addUpstreams([upstream1.signal, upstream2.signal])
+
+  upstream1.abort("first")
+  abortManager.tryToAbort()
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream2.abort("second")
+  abortManager.tryToAbort()
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("AbortManager.abort aborts and applies auto-remove policy", () => {
+  class TestAbortManager extends AbortManager {
+    removeAllUpstreamsCalled = 0
+
+    override removeAllUpstreams(): this {
+      this.removeAllUpstreamsCalled = this.removeAllUpstreamsCalled + 1
+      return super.removeAllUpstreams()
+    }
+  }
+
+  const enabled = new TestAbortManager({ autoRemoveUpstreamsAfterAbort: true })
+  enabled.addUpstreams([new AbortController().signal])
+  enabled.abort("enabled")
+
+  const disabled = new TestAbortManager({ autoRemoveUpstreamsAfterAbort: false })
+  disabled.addUpstreams([new AbortController().signal])
+  disabled.abort("disabled")
+
+  expect(enabled.isAborted()).toBe(true)
+  expect(enabled.removeAllUpstreamsCalled).toBe(1)
+  expect(disabled.isAborted()).toBe(true)
+  expect(disabled.removeAllUpstreamsCalled).toBe(0)
+})
+
+test("fromAbortable creates manager from a single upstream abortable", () => {
+  const upstream = new AbortController()
+  const abortManager = fromAbortable(upstream)
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream.abort("stop")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("any creates manager that aborts when any upstream aborts", () => {
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+  const abortManager = any([upstream1.signal, null, undefined, upstream2.signal])
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream1.abort("first")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("all creates manager that aborts only when all upstreams abort", () => {
+  const upstream1 = new AbortController()
+  const upstream2 = new AbortController()
+  const abortManager = all([upstream1.signal, null, undefined, upstream2.signal])
+
+  upstream1.abort("first")
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream2.abort("second")
+
+  expect(abortManager.isAborted()).toBe(true)
+})
+
+test("fromWithAbortSignal creates manager from options.abortSignal", () => {
+  const upstream = new AbortController()
+  const withSignal = fromWithAbortSignal({ abortSignal: upstream.signal })
+  const withoutSignal = fromWithAbortSignal({})
+
+  expect(withSignal.isAborted()).toBe(false)
+  expect(withoutSignal.isAborted()).toBe(false)
+
+  upstream.abort("stop")
+
+  expect(withSignal.isAborted()).toBe(true)
+  expect(withoutSignal.isAborted()).toBe(false)
+})
+
+test("fromAbortFriendlyOptions creates manager using abort-friendly options", () => {
+  const upstream = new AbortManager({})
+  const abortManager = fromAbortFriendlyOptions({ abortManager: upstream })
+
+  expect(abortManager.isAborted()).toBe(false)
+
+  upstream.abort("stop")
+
+  expect(abortManager.isAborted()).toBe(true)
+})