@pmate/account-sdk 0.5.5 → 0.6.0

package/package.json

@@ -1,19 +1,15 @@
 {
   "name": "@pmate/account-sdk",
-  "version": "0.5.5",
-  "main": "./dist/index.cjs.js",
-  "module": "./dist/index.es.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.es.js",
-      "require": "./dist/index.cjs.js"
-    }
-  },
+  "version": "0.6.0",
+  "type": "module",
   "files": [
-    "dist"
+    "src",
+    "!src/tests",
+    "!src/tests/**"
   ],
+  "exports": {
+    ".": "./src/index.ts"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -26,7 +22,10 @@
     "browser-image-compression": "^2.0.2",
     "i18next": "^23.0.0",
     "react-i18next": "^13.0.0",
-    "react-use": "^17.6.0"
+    "react-use": "^17.6.0",
+    "@pmate/lang": "1.0.2",
+    "@pmate/utils": "1.0.3",
+    "@pmate/meta": "1.1.3"
   },
   "devDependencies": {
     "@types/react": "*",
@@ -34,18 +33,12 @@
     "@vitejs/plugin-react": "^4.2.1",
     "jsdom": "^26.1.0",
     "react-dom": "*",
-    "rollup": "^4.21.2",
-    "rollup-plugin-dts": "^6.1.1",
     "typescript": "^5.2.2",
     "vite": "^7.3.1",
-    "vitest": "^4.0.17",
-    "@pmate/utils": "1.0.0",
-    "@pmate/lang": "1.0.0",
-    "@pmate/meta": "1.1.1"
+    "vitest": "^4.0.17"
   },
   "scripts": {
-    "build": "vite build && rollup -c rollup.config.dts.ts",
-    "npm:publish": "pnpm build && npm publish --registry https://registry.npmjs.org/",
+    "npm:publish": "npm publish --registry https://registry.npmjs.org/",
     "test": "vitest run",
     "test:watch": "vitest"
   }

package/src/api/AccountService.ts

@@ -0,0 +1,97 @@
+import {
+  AuthLoginResponse,
+  AuthRequest,
+  AuthSession,
+  ServerResponse,
+  VCodeIssueRequest,
+  VCodeIssueResult,
+} from "@pmate/meta"
+import { lru } from "@pmate/utils"
+import { getAuthToken } from "../utils/tokenStorage"
+
+const AUTH_ENDPOINT = "https://auth-api-v2.pmate.chat"
+type AuthRequestInit = RequestInit & { token?: string; app?: string }
+
+export class AccountService {
+  private static sessionCached = lru(
+    (token?: string, app?: string) =>
+      AccountService.authRequest<AuthSession | null>("/session", {
+        method: "GET",
+        token,
+        app,
+      }),
+    {
+      ttl: 3_000,
+      key: (token, app) => token ?? getAuthToken(app) ?? `default:${app ?? ""}`,
+    }
+  )
+  public static async vcode(
+    payload: VCodeIssueRequest
+  ): Promise<VCodeIssueResult> {
+    return AccountService.authRequest<VCodeIssueResult>("/vcode", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+  }
+
+  public static async login(request: AuthRequest): Promise<AuthLoginResponse> {
+    return AccountService.authRequest<AuthLoginResponse>("/login", {
+      method: "POST",
+      body: JSON.stringify(request),
+      token: request.nonce,
+      app: request.app,
+    })
+  }
+
+  public static async logout(token?: string, app?: string) {
+    return AccountService.authRequest<{ success: boolean }>("/logout", {
+      method: "POST",
+      token,
+      app,
+    })
+  }
+
+  public static async logoutAll(token?: string, app?: string) {
+    return AccountService.authRequest<{ success: boolean }>("/logout-all", {
+      method: "POST",
+      token,
+      app,
+    })
+  }
+
+  public static async session(token?: string, app?: string) {
+    return AccountService.sessionCached(token, app)
+  }
+
+  public static clearSessionCache() {
+    AccountService.sessionCached.clean()
+  }
+
+  private static async authRequest<T>(path: string, init: AuthRequestInit) {
+    const { token, headers, app, ...rest } = init
+    const resolvedToken = token ?? getAuthToken(app)
+    const url = new URL(`${AUTH_ENDPOINT.replace(/\/+$/, "")}${path}`)
+    if (app) {
+      url.searchParams.set("app", app)
+    }
+    const response = await fetch(
+      url.toString(),
+      {
+        credentials: "include",
+        ...rest,
+        headers: {
+          "Content-Type": "application/json",
+          ...(resolvedToken
+            ? { Authorization: `Bearer ${resolvedToken}` }
+            : {}),
+          ...(headers ?? {}),
+        },
+      }
+    )
+    const json = (await response.json()) as ServerResponse<T>
+    if (!response.ok || !json.success) {
+      throw json
+    }
+    return json.data
+  }
+}

package/src/api/Api.ts

@@ -0,0 +1,99 @@
+import { Maybe, isMaybe } from "@pmate/utils"
+import { ServerResponse } from "@pmate/meta"
+import { cacheInMem } from "./cacheInMem"
+
+const checkLink = async (url: string | Maybe<string>): Promise<boolean> => {
+  if (isMaybe(url)) {
+    if (url.isNothing()) {
+      return false
+    }
+    url = url.unwrap()
+  }
+  try {
+    const response = await fetch(url, { method: "HEAD" })
+    return response.ok
+  } catch {
+    return false
+  }
+}
+
+const cachedLinkCheck = cacheInMem(checkLink, "link", 60 * 60 * 1000)
+
+export class Api {
+  public static async get<T>(url: string): Promise<T | null> {
+    const response = await fetch(url)
+    if (!response.ok) {
+      return null
+    }
+    const json = (await response.json()) as ServerResponse<T>
+    return json.data ?? null
+  }
+
+  public static async post<T>(url: string, body: unknown): Promise<T> {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    })
+    const json = (await response.json()) as ServerResponse<T>
+    if (!json.success) {
+      throw json
+    }
+    return json.data as T
+  }
+
+  public static async put<T>(url: string, body: unknown): Promise<Maybe<T>> {
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    })
+    const json = (await response.json()) as ServerResponse<T>
+    if (!json.success) {
+      throw json
+    }
+    return Maybe.Just<T>(json.data)
+  }
+
+  public static async getFile<T>(url: string): Promise<T | null>
+  public static async getFile<T>(url: string, type: "json"): Promise<T | null>
+  public static async getFile(url: string, type: "text"): Promise<string | null>
+  public static async getFile<T>(url: string, type: "log"): Promise<Maybe<T[]>>
+  public static async getFile<T>(
+    url: string,
+    type: "json" | "text" | "log" = "json"
+  ): Promise<T | string | Maybe<T[]> | null> {
+    try {
+      const response = await fetch(url)
+      if (type === "log") {
+        if (!response.ok) {
+          return Maybe.Nothing()
+        }
+        try {
+          const text = await response.text()
+          const logs = text
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => JSON.parse(line) as T)
+          return Maybe.Just(logs)
+        } catch {
+          return Maybe.Nothing()
+        }
+      }
+      if (!response.ok) {
+        return null
+      }
+      if (type === "text") {
+        return response.text()
+      }
+      return (await response.json()) as T
+    } catch (error) {
+      console.warn(error)
+      return null
+    }
+  }
+
+  public static exists(url: string | Maybe<string>): Promise<boolean> {
+    return cachedLinkCheck(url)
+  }
+}

package/src/api/AppService.ts

@@ -0,0 +1,71 @@
+import { lru } from "@pmate/utils"
+import type { AppConfig, ProfileStep } from "../types/app"
+
+const APPS_ENDPOINT = "https://apps-api.pmate.chat"
+const DEFAULT_BACKGROUND = "linear-gradient(180deg, #9ca3af 0%, #6b7280 100%)"
+const DEFAULT_ICON = "https://parrot-static.pmate.chat/parrot-logo.png"
+
+type AppRegistryRecord = {
+  id: string
+  name: string
+  icon: string
+  theme?: {
+    background?: string
+    themeColor?: string
+    welcomeText?: string
+  }
+  profileSchema?: ProfileStep[]
+}
+
+const buildDisplayNameFromAppId = (appId: string): string => {
+  const normalized = appId.replace(/^@/, "")
+  const segments = normalized.split("/").filter(Boolean)
+  const last = segments[segments.length - 1] || normalized
+  return last || "App"
+}
+
+const toAppConfig = (record: AppRegistryRecord): AppConfig => {
+  const fallbackName = buildDisplayNameFromAppId(record.id)
+  return {
+    id: record.id,
+    name: record.name || fallbackName,
+    icon: record.icon || DEFAULT_ICON,
+    background: record.theme?.background || DEFAULT_BACKGROUND,
+    themeColor: record.theme?.themeColor,
+    welcomeText: record.theme?.welcomeText || `Welcome to ${fallbackName}`,
+    profiles: record.profileSchema ?? [],
+  }
+}
+
+const getAppConfigCached = lru(
+  async (appId: string): Promise<AppConfig> => {
+    const response = await fetch(
+      `${APPS_ENDPOINT.replace(/\/+$/, "")}/apps/${encodeURIComponent(appId)}`
+    )
+    if (!response.ok) {
+      throw new Error(`Failed to load app config (${response.status})`)
+    }
+    const json = (await response.json()) as {
+      success?: boolean
+      data?: AppRegistryRecord
+    }
+    if (!json.success || !json.data) {
+      throw new Error("Failed to load app config")
+    }
+    return toAppConfig(json.data)
+  },
+  {
+    ttl: 60_000,
+    key: (appId) => appId,
+  }
+)
+
+export class AppService {
+  public static async getAppConfig(appId: string): Promise<AppConfig> {
+    return getAppConfigCached(appId)
+  }
+
+  public static clearAppConfigCache() {
+    getAppConfigCached.clean()
+  }
+}

package/src/api/EntityService.ts

@@ -0,0 +1,41 @@
+import { GroupInfo, Profile } from "@pmate/meta"
+import { Api } from "./Api"
+
+const endpoint = "https://api-global-qa.skedo.cn/account"
+
+export class EntityService {
+  public static async entity<T>(id: string): Promise<T | null> {
+    return (await Api.get<T>(`${endpoint}/entity/${id}`)) || null
+  }
+
+  public static getProfile(id: string): Promise<Profile | null> {
+    return EntityService.entity<Profile>(id)
+  }
+
+  public static getGroup(id: string): Promise<GroupInfo | null> {
+    return EntityService.entity<GroupInfo>(id)
+  }
+
+  public static async entities<T extends { id?: string }>(
+    ids: string[]
+  ): Promise<Record<string, T>> {
+    if (!ids.length) {
+      return {}
+    }
+    const url = `${endpoint}/entities`
+    const list =
+      (await Api.post<T[]>(url, {
+        ids,
+      })) || []
+    return list.reduce<Record<string, T>>((acc, entity, index) => {
+      if (!entity) {
+        return acc
+      }
+      const key = entity.id ?? ids[index]
+      if (key) {
+        acc[key] = entity
+      }
+      return acc
+    }, {})
+  }
+}

package/src/api/ProfileService.ts

@@ -0,0 +1,133 @@
+import {
+  AccountState,
+  CreateProfileRequest,
+  Profile,
+  ProfileScope,
+  UpdateProfileRequest,
+} from "@pmate/meta"
+import { resolveAppId } from "../utils/resolveAppId"
+import { Api } from "./Api"
+
+const PROFILE_ENDPOINT = "https://auth-api-v2.pmate.chat"
+const UPLOADER_SERVICE_URL = "https://fc-uploader.skedo.cn".replace(/\/+$/, "")
+
+const EXTENSION_CONTENT_TYPE: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  bmp: "image/bmp",
+  pdf: "application/pdf",
+  mobi: "application/x-mobipocket-ebook",
+  epub: "application/epub+zip",
+  txt: "text/plain",
+  json: "application/json",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  webm: "audio/webm",
+  weba: "audio/webm",
+  m4a: "audio/mp4",
+}
+
+type UploadRequest = {
+  user: string
+  base64: string
+  filename?: string
+  text?: string
+  contentType?: string
+}
+
+export class ProfileService {
+  public static async createProfile(
+    req: CreateProfileRequest,
+  ): Promise<Profile> {
+    return Api.post<Profile>(`${PROFILE_ENDPOINT}/profile`, req)
+  }
+
+  public static async updateProfile(req: UpdateProfileRequest) {
+    await Api.put(`${PROFILE_ENDPOINT}/profile`, req)
+  }
+
+  public static async getProfiles(account: AccountState) {
+    const scope: ProfileScope = {
+      app: resolveAppId(account.app),
+      account: account.accountId,
+    }
+    return ProfileService.getProfilesByScope(scope)
+  }
+
+  public static async getProfilesByScope(scope: ProfileScope) {
+    const query = new URLSearchParams({
+      app: scope.app,
+      account: scope.account,
+    }).toString()
+    return (
+      (await Api.get<Profile[]>(`${PROFILE_ENDPOINT}/profiles?${query}`)) || []
+    )
+  }
+
+  public static async updateAvatar(req: {
+    user: string
+    base64: string
+    filename: string
+  }): Promise<string> {
+    return ProfileService.uploadToUploaderService("/avatar", req)
+  }
+
+  public static async uploadMsgImage(req: {
+    user: string
+    base64: string
+    filename: string
+  }): Promise<string> {
+    return ProfileService.uploadToUploaderService("/msg", req)
+  }
+
+  public static async updateMyVoice(req: {
+    user: string
+    base64: string
+    text: string
+  }): Promise<string> {
+    return ProfileService.uploadToUploaderService("/my-voice", {
+      ...req,
+      filename: "voice.wav",
+      contentType: "audio/wav",
+    })
+  }
+
+  public static async uploadUserFile(req: {
+    user: string
+    base64: string
+    filename: string
+  }) {
+    return ProfileService.uploadToUploaderService("/file", req)
+  }
+
+  private static async uploadToUploaderService(
+    path: string,
+    payload: UploadRequest,
+  ): Promise<string> {
+    const { filename, ...rest } = payload
+    const resolvedFilename = filename ?? "upload"
+    const ext = resolvedFilename.split(".").pop()?.toLowerCase() ?? ""
+    const contentType = payload.contentType ?? EXTENSION_CONTENT_TYPE[ext]
+    const response = await fetch(`${UPLOADER_SERVICE_URL}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(contentType ? { "x-file-content-type": contentType } : {}),
+      },
+      body: JSON.stringify({ ...rest, filename: resolvedFilename }),
+    })
+    if (!response.ok) {
+      throw new Error("Upload failed")
+    }
+    const json = (await response.json()) as { data?: string }
+    if (!json.data) {
+      throw new Error("Upload failed")
+    }
+    return json.data
+  }
+}

package/src/api/cacheInMem.ts

@@ -0,0 +1,73 @@
+type MaybeLike<T = unknown> = {
+  map: (fn: (value: T) => unknown) => MaybeLike
+  unwrapOr: (fallback: unknown) => unknown
+}
+
+const isMaybeLike = (value: unknown): value is MaybeLike => {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "map" in value &&
+    typeof (value as MaybeLike).map === "function" &&
+    "unwrapOr" in value &&
+    typeof (value as MaybeLike).unwrapOr === "function"
+  )
+}
+
+const calculateSHA1Hash = async (value: string): Promise<string> => {
+  const data = new TextEncoder().encode(value)
+  const digest = await crypto.subtle.digest("SHA-1", data)
+  return Array.from(new Uint8Array(digest))
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("")
+}
+
+export const cacheInMem = <T extends (...args: any[]) => Promise<any>>(
+  fn: T,
+  prefix: string,
+  timeout: number
+): T => {
+  const cache = new Map<string, { value: any; expiry: number }>()
+  const ongoingRequests = new Map<string, Promise<any>>()
+
+  return (async (...args: Parameters<T>): Promise<ReturnType<T>> => {
+    const hashRaw = args
+      .map((x) => {
+        if (isMaybeLike(x)) {
+          return x.map((item) => JSON.stringify(item)).unwrapOr("")
+        }
+        return JSON.stringify(x)
+      })
+      .join("--")
+
+    const hash = await calculateSHA1Hash(hashRaw)
+    const cacheKey = `${prefix}:${hash}`
+
+    const cached = cache.get(cacheKey)
+    if (cached && cached.expiry > Date.now()) {
+      return cached.value
+    }
+
+    const ongoingRequest = ongoingRequests.get(cacheKey)
+    if (ongoingRequest) {
+      return ongoingRequest
+    }
+
+    const requestPromise = (async () => {
+      try {
+        const result = await fn(...args)
+
+        if (result) {
+          cache.set(cacheKey, { value: result, expiry: Date.now() + timeout })
+        }
+        return result
+      } finally {
+        setTimeout(() => ongoingRequests.delete(cacheKey), 50)
+      }
+    })()
+
+    ongoingRequests.set(cacheKey, requestPromise)
+
+    return requestPromise
+  }) as T
+}

package/src/api/index.ts

@@ -0,0 +1,5 @@
+export * from "./Api"
+export * from "./AccountService"
+export * from "./AppService"
+export * from "./ProfileService"
+export * from "./EntityService"

package/src/atoms/accountAtom.ts

@@ -0,0 +1,18 @@
+import { atom } from "jotai"
+import {
+  AccountLifecycleState,
+  AccountSnapshot as AccountSnapshotType,
+} from "../types/account.types"
+
+export type AccountSnapshot = AccountSnapshotType
+
+const emptySnapshot: AccountSnapshot = {
+  state: AccountLifecycleState.Idle,
+  profiles: [],
+  profile: null,
+  accountId: null,
+  account: null,
+  error: null,
+}
+
+export const accountAtom = atom<AccountSnapshot>(emptySnapshot)

package/src/atoms/accountProfileAtom.ts

@@ -0,0 +1,13 @@
+import { AccountState, Profile } from "@pmate/meta"
+import { atom } from "jotai"
+import { accountAtom } from "./accountAtom"
+
+export const accountStateAtom = atom((get): AccountState | undefined => {
+  const account = get(accountAtom).account
+  return account ?? undefined
+})
+
+export const profileAtom = atom((get): Profile | undefined => {
+  const profile = get(accountAtom).profile
+  return profile ?? undefined
+})

package/src/atoms/atomWithLoadable.ts

@@ -0,0 +1,48 @@
+import { isLoadable, Loadable } from "@pmate/utils"
+import { atom, type Atom, type Getter } from "jotai"
+import { unwrap } from "jotai/utils"
+
+type AsyncFn<T> = (get: Getter) => Promise<T | Loadable<T> | undefined | null>
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T
+interface LoadableOption<T> {
+  isValid?: (result: UnwrapPromise<ReturnType<AsyncFn<T>>>) => boolean
+  placeHolderBehavior?: "pending" | "stale"
+  placeHolderValue?: T
+}
+
+export const atomWithLoadable = <T>(
+  asyncFn: AsyncFn<T>,
+  options: LoadableOption<T> = {
+    isValid: undefined,
+    placeHolderBehavior: "pending",
+  },
+) => {
+  const baseAtom = atom(async (get) => {
+    try {
+      const result = await asyncFn(get)
+      if (isLoadable(result)) {
+        return result
+      }
+      if (typeof result === "undefined" || result === null) {
+        return Loadable.Nothing<T>()
+      }
+      if (options?.isValid && !options.isValid(result)) {
+        return Loadable.Nothing<T>()
+      }
+      return Loadable.Just<T>(result)
+    } catch (error: any) {
+      return Loadable.Fail<T>(error)
+    }
+  })
+
+  return unwrap(baseAtom, (prev) => {
+    const { placeHolderBehavior, placeHolderValue } = options
+    if (placeHolderValue) {
+      return Loadable.Pending<T>(placeHolderValue)
+    }
+    if (placeHolderBehavior === "stale" && prev?.isJust()) {
+      return Loadable.Pending<T>(prev.unwrap())
+    }
+    return Loadable.Pending<T>()
+  }) as Atom<Loadable<T>>
+}

package/src/atoms/createProfileAtom.ts

@@ -0,0 +1,27 @@
+import { atom } from "jotai"
+import { AccountManagerV2 } from "../utils/AccountManagerV2"
+import { profileDraftAtom } from "./profileDraftAtom"
+import { resolveAppId } from "../utils/resolveAppId"
+
+type CreateProfileParams = {
+  nickName: string
+}
+
+export const createProfileAtom = atom(
+  null,
+  async (get, _set, { nickName }: CreateProfileParams) => {
+    const draft = get(profileDraftAtom)
+    const bootstrapManager = AccountManagerV2.get(resolveAppId())
+    const account = await bootstrapManager.getAccountState()
+
+    if (!account) {
+      throw new Error("Account info is missing for profile creation")
+    }
+
+    const manager = AccountManagerV2.get(resolveAppId(account.app))
+    return manager.createProfile({
+      nickName,
+      learningTargetLang: draft.learningTargetLang,
+    })
+  }
+)