@pmate/account-sdk 0.5.4 → 0.6.0

package/src/utils/AccountManagerV2.ts

@@ -0,0 +1,349 @@
+import { EmitterV2 } from "@pmate/utils"
+import {
+  AccountState,
+  LangShort,
+  LocalProfileState,
+  Profile,
+  RoomPeerInfo,
+} from "@pmate/meta"
+import { AccountLifecycleState } from "../types/account.types"
+import type { AccountSnapshot } from "../types/account.types"
+import { AccountService, ProfileService } from "../api"
+import { clearAccountState, setAccountState } from "./accountStorage"
+import { resolveAppId } from "./resolveAppId"
+import {
+  clearSelectedProfileId,
+  getSelectedProfileId,
+  setSelectedProfileId,
+} from "./selectedProfileStorage"
+import { clearAuthToken, getAuthToken, setAuthToken } from "./tokenStorage"
+
+export enum AccountManagerEvent {
+  StateChange = "stateChange",
+}
+
+export type AccountManagerEventMap = {
+  [AccountManagerEvent.StateChange]: void
+}
+
+export class AccountManagerV2 extends EmitterV2<AccountManagerEventMap> {
+  private static instances = new Map<string, AccountManagerV2>()
+
+  constructor(private readonly app: string) {
+    super()
+  }
+
+  public static get(app?: string): AccountManagerV2 {
+    const resolvedApp = resolveAppId(app)
+    const existing = AccountManagerV2.instances.get(resolvedApp)
+    if (existing) {
+      return existing
+    }
+    const manager = new AccountManagerV2(resolvedApp)
+    AccountManagerV2.instances.set(resolvedApp, manager)
+    return manager
+  }
+
+  public async session() {
+    try {
+      return await AccountService.session(undefined, this.app)
+    } catch (error) {
+      return null
+    }
+  }
+
+  public async login(): Promise<AccountState> {
+    this.transition(AccountLifecycleState.LoggingIn, null)
+    try {
+      const session = await AccountService.session(undefined, this.app)
+      if (!session) {
+        throw new Error("Session not found")
+      }
+      const issuedAtMs = Date.parse(session.issuedAt)
+      const state: AccountState = {
+        accountId: session.identity.accountId,
+        token: "",
+        signTime: Number.isNaN(issuedAtMs) ? Date.now() : issuedAtMs,
+        app: this.app,
+      }
+      this.setAccountState(state)
+      this.transition(AccountLifecycleState.Authenticated, null)
+      this.transition(AccountLifecycleState.ProfileInitializing, null)
+      const profiles = await this.prepareProfiles(state)
+      this.transition(
+        profiles.length > 0
+          ? AccountLifecycleState.ProfileReady
+          : AccountLifecycleState.ProfileUninitialized,
+        null,
+      )
+      return state
+    } catch (error) {
+      const nextError =
+        error instanceof Error ? error : new Error("Login failed")
+      this.transition(AccountLifecycleState.Error, nextError)
+      throw nextError
+    }
+  }
+
+  public hasUrlSession(): boolean {
+    if (typeof window === "undefined") {
+      return false
+    }
+    const params = new URLSearchParams(window.location.search)
+    return params.has("sessionId")
+  }
+
+  /**
+   * When a URL contains a sessionId parameter, this method logs in the user.
+   * If URL does not contain a sessionId parameter, this method logs in from existing session.
+   */
+  public async loginUrlSessionOverride(): Promise<AccountState> {
+    if (typeof window === "undefined") {
+      return this.login()
+    }
+    const params = new URLSearchParams(window.location.search)
+    const sessionId = params.get("sessionId")
+    if (sessionId) {
+      this.setAuthToken(sessionId)
+    }
+    const account = await this.login()
+    if (sessionId) {
+      params.delete("sessionId")
+      const nextSearch = params.toString()
+      const nextUrl = `${window.location.pathname}${
+        nextSearch ? `?${nextSearch}` : ""
+      }${window.location.hash}`
+      window.history.replaceState(null, "", nextUrl)
+    }
+    return account
+  }
+
+  public async logout(scope: "app" | "all" = "app"): Promise<void> {
+    this.transition(AccountLifecycleState.LoggingOut, null)
+    try {
+      const token = getAuthToken(this.app) || undefined
+      if (scope === "all") {
+        await AccountService.logoutAll(token, this.app)
+      } else {
+        await AccountService.logout(token, this.app)
+      }
+    } catch {
+      // ignore logout failures to ensure local session is cleared
+    } finally {
+      if (scope === "all") {
+        AccountManagerV2.clearAllLocalSessions()
+      } else {
+        this.clearSession()
+      }
+      this.transition(AccountLifecycleState.Unauthenticated, null)
+    }
+  }
+
+  public async getSnapshot(): Promise<AccountSnapshot> {
+    const account = await this.getAccountState()
+    if (!account) {
+      return {
+        state: AccountLifecycleState.Unauthenticated,
+        account: null,
+        accountId: null,
+        error: null,
+        profiles: [],
+        profile: null,
+      }
+    }
+    const profiles = await this.getProfiles()
+    const profile = await this.getSelectedProfile(profiles)
+    const state =
+      profiles.length > 0
+        ? AccountLifecycleState.ProfileReady
+        : AccountLifecycleState.ProfileUninitialized
+    return {
+      state,
+      account,
+      accountId: account.accountId ?? null,
+      error: null,
+      profiles,
+      profile,
+    }
+  }
+
+  public transition(next: AccountLifecycleState, error?: Error | null): void {
+    void next
+    void error
+    this.emit(AccountManagerEvent.StateChange)
+  }
+
+  public async getAccountState(): Promise<AccountState | null> {
+    const session = await this.session()
+    if (!session) {
+      return null
+    }
+    const issuedAtMs = Date.parse(session.issuedAt)
+    const state: AccountState = {
+      accountId: session.identity.accountId,
+      token: getAuthToken(this.app) || "",
+      signTime: Number.isNaN(issuedAtMs) ? Date.now() : issuedAtMs,
+      app: this.app,
+    }
+    return state
+  }
+
+  public setAccountState(state: AccountState): void {
+    setAccountState(state, this.app)
+  }
+
+  public clearAccountState(): void {
+    clearAccountState(this.app)
+  }
+
+  public async getSelectedProfile(
+    profiles?: Profile[],
+  ): Promise<Profile | null> {
+    const storedId = getSelectedProfileId(this.app)
+    if (!storedId) {
+      return null
+    }
+    const resolvedProfiles = profiles ?? (await this.getProfiles())
+    return resolvedProfiles.find((profile) => profile.id === storedId) ?? null
+  }
+
+  public setSelectedProfile(
+    profile: Profile | LocalProfileState | string,
+  ): void {
+    const nextId = typeof profile === "string" ? profile : profile.id
+    setSelectedProfileId(nextId, this.app)
+    this.emit(AccountManagerEvent.StateChange)
+  }
+
+  public clearSelectedProfile(): void {
+    clearSelectedProfileId(this.app)
+    this.emit(AccountManagerEvent.StateChange)
+  }
+
+  public async getProfiles(): Promise<Profile[]> {
+    const account = await this.getAccountState()
+    if (!account) {
+      return []
+    }
+    try {
+      return await this.prepareProfiles(account)
+    } catch {
+      return []
+    }
+  }
+
+  public clearProfiles(): void {
+    this.emit(AccountManagerEvent.StateChange)
+  }
+
+  public clearSession(): void {
+    this.clearAccountState()
+    this.clearSelectedProfile()
+    this.clearProfiles()
+    this.clearAuthToken()
+  }
+
+  public getAuthToken(): string | null {
+    return getAuthToken(this.app)
+  }
+
+  public setAuthToken(token: string): void {
+    setAuthToken(token, this.app)
+    AccountService.clearSessionCache()
+    this.emit(AccountManagerEvent.StateChange)
+  }
+
+  public clearAuthToken(): void {
+    clearAuthToken(this.app)
+    AccountService.clearSessionCache()
+    this.emit(AccountManagerEvent.StateChange)
+  }
+
+  private static clearAllLocalSessions() {
+    if (typeof localStorage === "undefined") {
+      return
+    }
+
+    const prefixes = [
+      "pmate-auth-token:",
+      "account-state-v2:",
+      "selected-profile-v2:",
+    ]
+    const keysToRemove: string[] = []
+    for (let index = 0; index < localStorage.length; index += 1) {
+      const key = localStorage.key(index)
+      if (!key) continue
+      if (prefixes.some((prefix) => key.startsWith(prefix))) {
+        keysToRemove.push(key)
+      }
+    }
+
+    for (const key of keysToRemove) {
+      localStorage.removeItem(key)
+    }
+
+    AccountService.clearSessionCache()
+    for (const manager of AccountManagerV2.instances.values()) {
+      manager.emit(AccountManagerEvent.StateChange)
+    }
+  }
+
+  public async getLocalProfile(): Promise<LocalProfileState | null> {
+    const account = await this.getAccountState()
+    const profile = await this.getSelectedProfile()
+    if (!account || !profile) {
+      return null
+    }
+    const { id, ...rest } = profile
+    return { ...account, ...rest, id } as LocalProfileState
+  }
+
+  public async getCurrentPeer(): Promise<RoomPeerInfo | undefined> {
+    const user = await this.getLocalProfile()
+    if (!user) {
+      return
+    }
+    return {
+      ...user,
+      gender: user.gender ?? "",
+      email: user.email || "",
+      isOnline: true,
+    } as RoomPeerInfo
+  }
+
+  public async createProfile(payload: {
+    nickName: string
+    learningTargetLang?: LangShort
+  }): Promise<Profile> {
+    const account = await this.getAccountState()
+    if (!account) {
+      throw new Error("Account info is missing for profile creation")
+    }
+    const profile = await ProfileService.createProfile({
+      app: resolveAppId(account.app),
+      account: account.accountId,
+      nickName: payload.nickName,
+      learningTargetLang: payload.learningTargetLang,
+    })
+    await this.prepareProfiles(account)
+    if (!(await this.getSelectedProfile())) {
+      this.setSelectedProfile(profile)
+    }
+    return profile
+  }
+
+  private async prepareProfiles(account: AccountState): Promise<Profile[]> {
+    const profiles = await ProfileService.getProfiles(account)
+    const storedId = getSelectedProfileId(this.app)
+    if (storedId && profiles.some((profile) => profile.id === storedId)) {
+      return profiles
+    }
+    const nextSelected = profiles[0]
+    if (nextSelected) {
+      this.setSelectedProfile(nextSelected)
+    } else {
+      this.clearSelectedProfile()
+    }
+    return profiles
+  }
+}

package/src/utils/Redirect.ts

@@ -0,0 +1,17 @@
+const AUTH_APP_BASE = "https://auth.pmate.chat"
+
+export class Redirect {
+  static toLogin(app: string, redirect?: string) {
+    const url = new URL(AUTH_APP_BASE)
+    url.searchParams.set("redirect", redirect ?? window.location.href)
+    url.searchParams.set("app", app)
+    window.location.href = url.toString()
+  }
+
+  static toCreateProfile(app: string, redirect?: string) {
+    const url = new URL("/create-profile", AUTH_APP_BASE)
+    url.searchParams.set("redirect", redirect ?? window.location.href)
+    url.searchParams.set("app", app)
+    window.location.href = url.toString()
+  }
+}

package/src/utils/accountStorage.ts

@@ -0,0 +1,46 @@
+import type { AccountState } from "@pmate/meta"
+import { resolveAppId } from "./resolveAppId"
+
+export const ACCOUNT_STATE_KEY = "account-state-v2"
+
+const canUseStorage = () => typeof localStorage !== "undefined"
+
+const buildAccountStateStorageKey = (app?: string): string =>
+  `${ACCOUNT_STATE_KEY}:${resolveAppId(app)}`
+
+export const getAccountState = (app?: string): AccountState | null => {
+  if (!canUseStorage()) {
+    return null
+  }
+  try {
+    const raw = localStorage.getItem(buildAccountStateStorageKey(app))
+    if (!raw) {
+      return null
+    }
+    return JSON.parse(raw) as AccountState
+  } catch {
+    return null
+  }
+}
+
+export const setAccountState = (state: AccountState, app?: string): void => {
+  if (!canUseStorage()) {
+    return
+  }
+  try {
+    localStorage.setItem(buildAccountStateStorageKey(app), JSON.stringify(state))
+  } catch {
+    // ignore write errors
+  }
+}
+
+export const clearAccountState = (app?: string): void => {
+  if (!canUseStorage()) {
+    return
+  }
+  try {
+    localStorage.removeItem(buildAccountStateStorageKey(app))
+  } catch {
+    // ignore delete errors
+  }
+}

package/src/utils/errors.ts

@@ -0,0 +1 @@
+export class NotAuthenticatedError extends Error {}

package/src/utils/index.ts

@@ -0,0 +1,11 @@
+export {
+  getLangFull,
+  isNicknameValid,
+  legacyLangMap,
+  normalizeLang,
+} from "@pmate/lang"
+export * from "./AccountManagerV2"
+export * from "./resolveAppId"
+export * from "./errors"
+export * from "./profileStep"
+export * from "./Redirect"

package/src/utils/location.ts

@@ -0,0 +1,34 @@
+const LOCATION_CHANGE_EVENT = "pmate:locationchange"
+
+const ensureLocationEvents = () => {
+  const history = window.history as History & { __pmatePatched?: boolean }
+  if (history.__pmatePatched) {
+    return
+  }
+  history.__pmatePatched = true
+  const notify = () => window.dispatchEvent(new Event(LOCATION_CHANGE_EVENT))
+  const wrap = (type: "pushState" | "replaceState") => {
+    const original = history[type]
+    history[type] = function (...args) {
+      const result = original.apply(
+        history,
+        args as Parameters<History["pushState"]>
+      )
+      notify()
+      return result
+    } as History["pushState"]
+  }
+  wrap("pushState")
+  wrap("replaceState")
+  window.addEventListener("popstate", notify)
+}
+
+export const subscribeToLocationChange = (listener: () => void) => {
+  ensureLocationEvents()
+  window.addEventListener(LOCATION_CHANGE_EVENT, listener)
+  return () => window.removeEventListener(LOCATION_CHANGE_EVENT, listener)
+}
+
+export const getWindowPathname = () => window.location.pathname
+
+export const getWindowSearch = () => window.location.search

package/src/utils/profileStep.ts

@@ -0,0 +1,26 @@
+export type ProfileStepType =
+  | "nickname"
+  | "learning-language"
+  | "mother-tongue"
+  | "gender"
+  | "is-adult"
+  | "age"
+
+const PROFILE_STEP_TYPE_SET: Record<ProfileStepType, true> = {
+  nickname: true,
+  "learning-language": true,
+  "mother-tongue": true,
+  gender: true,
+  "is-adult": true,
+  age: true,
+}
+
+export const isProfileStepType = (value: string): value is ProfileStepType => {
+  return Boolean(PROFILE_STEP_TYPE_SET[value as ProfileStepType])
+}
+
+export interface ProfileStep {
+  type: ProfileStepType
+  title: string
+  required: boolean
+}

package/src/utils/resolveAppId.ts

@@ -0,0 +1,13 @@
+export const resolveAppId = (fallbackApp?: string) => {
+  const envApp = ""
+  if (envApp) {
+    return envApp
+  }
+  if (typeof window !== "undefined") {
+    const urlApp = new URLSearchParams(window.location.search).get("app")
+    if (urlApp) {
+      return urlApp
+    }
+  }
+  return fallbackApp || "pmate"
+}

package/src/utils/selectedProfileStorage.ts

@@ -0,0 +1,46 @@
+import { resolveAppId } from "./resolveAppId"
+
+export const SELECTED_PROFILE_KEY = "selected-profile-v2"
+
+const canUseStorage = () => typeof localStorage !== "undefined"
+
+const buildSelectedProfileStorageKey = (app?: string): string =>
+  `${SELECTED_PROFILE_KEY}:${resolveAppId(app)}`
+
+export const getSelectedProfileId = (app?: string): string | null => {
+  if (!canUseStorage()) {
+    return null
+  }
+  try {
+    const raw = localStorage.getItem(buildSelectedProfileStorageKey(app))
+    if (!raw) {
+      return null
+    }
+    const parsed = JSON.parse(raw) as unknown
+    return typeof parsed === "string" ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+export const setSelectedProfileId = (id: string, app?: string): void => {
+  if (!canUseStorage()) {
+    return
+  }
+  try {
+    localStorage.setItem(buildSelectedProfileStorageKey(app), JSON.stringify(id))
+  } catch {
+    // ignore write errors
+  }
+}
+
+export const clearSelectedProfileId = (app?: string): void => {
+  if (!canUseStorage()) {
+    return
+  }
+  try {
+    localStorage.removeItem(buildSelectedProfileStorageKey(app))
+  } catch {
+    // ignore delete errors
+  }
+}

package/src/utils/tokenStorage.ts

@@ -0,0 +1,47 @@
+import { resolveAppId } from "./resolveAppId"
+
+export const TOKEN_STORAGE_KEY = "pmate-auth-token"
+
+const canUseStorage = () => typeof localStorage !== "undefined"
+
+const buildTokenStorageKey = (app?: string): string => {
+  return `${TOKEN_STORAGE_KEY}:${resolveAppId(app)}`
+}
+
+export const getAuthToken = (app?: string): string | null => {
+  if (!canUseStorage()) {
+    return null
+  }
+  try {
+    const raw = localStorage.getItem(buildTokenStorageKey(app))
+    if (!raw) {
+      return null
+    }
+    const parsed = JSON.parse(raw) as unknown
+    return typeof parsed === "string" ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+export const setAuthToken = (token: string, app?: string): void => {
+  if (!canUseStorage()) {
+    return
+  }
+  try {
+    localStorage.setItem(buildTokenStorageKey(app), JSON.stringify(token))
+  } catch {
+    // ignore write errors
+  }
+}
+
+export const clearAuthToken = (app?: string): void => {
+  if (!canUseStorage()) {
+    return
+  }
+  try {
+    localStorage.removeItem(buildTokenStorageKey(app))
+  } catch {
+    // ignore delete errors
+  }
+}