@typexim/web-sdk 0.0.6 → 0.0.8

package/test/{chat-sdk-restore-login.test.mjs → chat-sdk-independent-login.test.mjs}

@@ -47,44 +47,20 @@ function installBrowserMocks() {
   storageListeners.clear();
   storageData.clear();
 
-  let lockHeld = false;
   Object.defineProperty(globalThis, 'navigator', {
     configurable: true,
-    value: {
-      locks: {
-        request: async (_name, options, callback) => {
-          if (lockHeld && options?.ifAvailable) {
-            return callback(null);
-          }
-
-          lockHeld = true;
-          try {
-            return await callback({});
-          } finally {
-            lockHeld = false;
-          }
-        },
-      },
-    },
+    value: {},
   });
   globalThis.BroadcastChannel = MockBroadcastChannel;
   globalThis.WebSocket = MockWebSocket;
   globalThis.window = {
-    addEventListener: (type, listener) => {
-      if (type === 'storage') storageListeners.add(listener);
-    },
-    removeEventListener: (type, listener) => {
-      if (type === 'storage') storageListeners.delete(listener);
-    },
+    addEventListener: () => {},
+    removeEventListener: () => {},
   };
   globalThis.localStorage = {
     getItem: (key) => storageData.get(key) ?? null,
     setItem: (key, value) => {
-      const oldValue = storageData.get(key) ?? null;
       storageData.set(key, value);
-      for (const listener of storageListeners) {
-        listener({ key, oldValue, newValue: value });
-      }
     },
     removeItem: (key) => storageData.delete(key),
   };
@@ -177,56 +153,68 @@ async function patchRelativeImports(source, sourceUrl) {
   return patched;
 }
 
-test('login restores an active tab session before calling session login API', async () => {
+test('two SDK instances can both be ready without a cross-tab lock', async () => {
   installBrowserMocks();
 
   await patchDistTestImports(new URL('../dist-test/', import.meta.url));
   const { default: ChatSDK } = await import('../dist-test/modules/ChatSDK.js');
 
-  const oldSdk = createSdk(ChatSDK);
-  oldSdk.context.deviceId = 'device-1';
-  oldSdk.context.isLogin = true;
-  oldSdk.context.isReady = true;
-  oldSdk.context.loginUser = {
-    userId: 'user-1',
-    secretKey: 'secret-1',
-    sessionId: 'session-1',
-  };
-  await oldSdk.singletonLock.requestLock();
+  const firstSdk = createSdk(ChatSDK);
+  const secondSdk = createSdk(ChatSDK);
+
+  let sessionLoginCalls = 0;
+
+  const mockPost = async (url, body) => {
+    if (url === '/device_api/device_id') {
+      return {
+        ok: true,
+        data: 'device-shared',
+      };
+    }
 
-  const newSdk = createSdk(ChatSDK);
-  let sessionLoginApiCalled = false;
-  newSdk.httpClient.post = async (url) => {
     if (url === '/user/session/login') {
-      sessionLoginApiCalled = true;
+      sessionLoginCalls += 1;
+      return {
+        ok: true,
+        data: {
+          id: `user-${body.userCode}`,
+          key: `secret-${body.userCode}`,
+        },
+      };
     }
+
     return {
       ok: false,
       code: -1,
-      msg: 'unexpected post',
+      msg: `unexpected post ${url}`,
     };
   };
 
+  firstSdk.httpClient.post = mockPost;
+  secondSdk.httpClient.post = mockPost;
+
   try {
-    const res = await newSdk.login({
-      user_code: 'session-1',
-    });
-
-    assert.equal(res.ok, true);
-    assert.equal(sessionLoginApiCalled, false);
-    assert.equal(newSdk.context.isLogin, true);
-    assert.equal(newSdk.context.isReady, true);
-    assert.deepEqual(newSdk.context.loginUser, {
-      userId: 'user-1',
-      secretKey: 'secret-1',
-      sessionId: 'session-1',
-    });
-    assert.equal(oldSdk.context.isLogin, false);
-    assert.equal(oldSdk.context.isReady, false);
+    // Wait for auto-restore timeouts so login does not share an in-flight restore.
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    const firstRes = await firstSdk.login({ user_code: 'code-a' });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const secondRes = await secondSdk.login({ user_code: 'code-a' });
+
+    assert.equal(firstRes.ok, true);
+    assert.equal(secondRes.ok, true);
+    // First login broadcasts session; second tab is already logged in and skips API.
+    assert.equal(sessionLoginCalls, 1);
+    assert.equal(firstSdk.context.isLogin, true);
+    assert.equal(firstSdk.context.isReady, true);
+    assert.equal(secondSdk.context.isLogin, true);
+    assert.equal(secondSdk.context.isReady, true);
+    assert.equal(firstSdk.context.loginUser?.sessionId, 'code-a');
+    assert.equal(secondSdk.context.loginUser?.sessionId, 'code-a');
   } finally {
-    await oldSdk.afterLogout();
-    await newSdk.afterLogout();
-    oldSdk.tabSessionCoordinator.destroy();
-    newSdk.tabSessionCoordinator.destroy();
+    firstSdk.afterLogout();
+    secondSdk.afterLogout();
+    firstSdk.tabSessionCoordinator.destroy();
+    secondSdk.tabSessionCoordinator.destroy();
   }
 });

package/test/chat-sdk-session-restore.test.mjs

@@ -0,0 +1,331 @@
+import assert from 'node:assert/strict';
+import { access, readdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const channels = new Set();
+const storageListeners = new Set();
+const storageData = new Map();
+
+class MockBroadcastChannel {
+  constructor(name) {
+    this.name = name;
+    this.onmessage = null;
+    channels.add(this);
+  }
+
+  postMessage(message) {
+    for (const channel of channels) {
+      if (channel !== this && channel.name === this.name && channel.onmessage) {
+        channel.onmessage({ data: message });
+      }
+    }
+  }
+
+  close() {
+    channels.delete(this);
+  }
+}
+
+class MockWebSocket {
+  static OPEN = 1;
+
+  constructor() {
+    this.OPEN = 1;
+    this.readyState = 1;
+    setTimeout(() => this.onopen?.(), 0);
+  }
+
+  send() {}
+
+  close() {}
+}
+
+function installBrowserMocks() {
+  channels.clear();
+  storageListeners.clear();
+  storageData.clear();
+
+  Object.defineProperty(globalThis, 'navigator', {
+    configurable: true,
+    value: {},
+  });
+  globalThis.BroadcastChannel = MockBroadcastChannel;
+  globalThis.WebSocket = MockWebSocket;
+  globalThis.window = {
+    addEventListener: (type, listener) => {
+      if (type === 'storage') storageListeners.add(listener);
+    },
+    removeEventListener: (type, listener) => {
+      if (type === 'storage') storageListeners.delete(listener);
+    },
+  };
+  globalThis.localStorage = {
+    getItem: (key) => storageData.get(key) ?? null,
+    setItem: (key, value) => {
+      const oldValue = storageData.get(key) ?? null;
+      storageData.set(key, value);
+      for (const listener of storageListeners) {
+        listener({ key, oldValue, newValue: value });
+      }
+    },
+    removeItem: (key) => storageData.delete(key),
+  };
+}
+
+function createSdk(ChatSDK) {
+  const sdk = new ChatSDK({
+    httpHost: 'https://example.test',
+    websocketHost: 'wss://example.test',
+  });
+
+  sdk.httpClient.get = async () => ({
+    ok: true,
+    data: null,
+  });
+
+  return sdk;
+}
+
+async function patchDistTestImports(dirUrl) {
+  const entries = await readdir(dirUrl, { withFileTypes: true });
+
+  await Promise.all(
+    entries.map(async (entry) => {
+      const entryUrl = new URL(
+        `${entry.name}${entry.isDirectory() ? '/' : ''}`,
+        dirUrl,
+      );
+
+      if (entry.isDirectory()) {
+        await patchDistTestImports(entryUrl);
+        return;
+      }
+
+      if (!entry.name.endsWith('.js')) {
+        return;
+      }
+
+      const source = await readFile(entryUrl, 'utf8');
+      const patched = await patchRelativeImports(source, entryUrl);
+
+      if (patched !== source) {
+        await writeFile(entryUrl, patched);
+      }
+    }),
+  );
+}
+
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function patchRelativeImports(source, sourceUrl) {
+  const sourcePath = fileURLToPath(sourceUrl);
+  const sourceDir = dirname(sourcePath);
+  const importRegex =
+    /(?<prefix>from\s+['"])(?<specifier>\.\.?\/[^'"]+)(?<suffix>['"])/g;
+  const matches = [...source.matchAll(importRegex)];
+  let patched = source;
+
+  for (const match of matches) {
+    const { prefix, specifier, suffix } = match.groups;
+
+    if (specifier.endsWith('.js')) {
+      continue;
+    }
+
+    const targetPath = resolve(sourceDir, specifier);
+    let nextSpecifier = specifier;
+
+    if (await pathExists(`${targetPath}.js`)) {
+      nextSpecifier = `${specifier}.js`;
+    } else if (await pathExists(resolve(targetPath, 'index.js'))) {
+      nextSpecifier = `${specifier}/index.js`;
+    }
+
+    if (nextSpecifier !== specifier) {
+      patched = patched.replaceAll(
+        `${prefix}${specifier}${suffix}`,
+        `${prefix}${nextSpecifier}${suffix}`,
+      );
+    }
+  }
+
+  return patched;
+}
+
+test('new tab restores neighbor session without login API and without kicking neighbor', async () => {
+  installBrowserMocks();
+
+  await patchDistTestImports(new URL('../dist-test/', import.meta.url));
+  const { default: ChatSDK } = await import('../dist-test/modules/ChatSDK.js');
+
+  const oldSdk = createSdk(ChatSDK);
+  oldSdk.context.deviceId = 'device-1';
+  oldSdk.context.isLogin = true;
+  oldSdk.context.isReady = true;
+  oldSdk.context.loginUser = {
+    userId: 'user-1',
+    secretKey: 'secret-1',
+    sessionId: 'session-1',
+  };
+
+  let sessionLoginApiCalled = false;
+  const newSdk = createSdk(ChatSDK);
+  newSdk.httpClient.post = async (url) => {
+    if (url === '/user/session/login') {
+      sessionLoginApiCalled = true;
+    }
+    return {
+      ok: false,
+      code: -1,
+      msg: 'unexpected post',
+    };
+  };
+
+  try {
+    // Wait for auto-restore scheduled in init.
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    assert.equal(newSdk.context.isLogin, true);
+    assert.equal(newSdk.context.isReady, true);
+    assert.equal(sessionLoginApiCalled, false);
+    assert.deepEqual(newSdk.context.loginUser, {
+      userId: 'user-1',
+      secretKey: 'secret-1',
+      sessionId: 'session-1',
+    });
+    assert.equal(oldSdk.context.isLogin, true);
+    assert.equal(oldSdk.context.isReady, true);
+
+    const loginRes = await newSdk.login({ user_code: 'session-1' });
+    assert.equal(loginRes.ok, true);
+    assert.equal(sessionLoginApiCalled, false);
+  } finally {
+    oldSdk.afterLogout();
+    newSdk.afterLogout();
+    oldSdk.tabSessionCoordinator.destroy();
+    newSdk.tabSessionCoordinator.destroy();
+  }
+});
+
+test('login on one tab notifies sibling tabs without calling login API again', async () => {
+  installBrowserMocks();
+
+  await patchDistTestImports(new URL('../dist-test/', import.meta.url));
+  const { default: ChatSDK } = await import('../dist-test/modules/ChatSDK.js');
+
+  const waitingSdk = createSdk(ChatSDK);
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  assert.equal(waitingSdk.context.isLogin, false);
+
+  const loggingInSdk = createSdk(ChatSDK);
+  await new Promise((resolve) => setTimeout(resolve, 20));
+
+  let sessionLoginCalls = 0;
+  loggingInSdk.httpClient.post = async (url) => {
+    if (url === '/device_api/device_id') {
+      return { ok: true, data: 'device-shared' };
+    }
+    if (url === '/user/session/login') {
+      sessionLoginCalls += 1;
+      return {
+        ok: true,
+        data: {
+          id: 'user-1',
+          key: 'secret-1',
+        },
+      };
+    }
+    return { ok: false, code: -1, msg: `unexpected post ${url}` };
+  };
+  waitingSdk.httpClient.post = async (url) => {
+    if (url === '/user/session/login') {
+      sessionLoginCalls += 1;
+    }
+    return { ok: false, code: -1, msg: `unexpected post ${url}` };
+  };
+
+  try {
+    const res = await loggingInSdk.login({ user_code: 'session-1' });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assert.equal(res.ok, true);
+    assert.equal(sessionLoginCalls, 1);
+    assert.equal(loggingInSdk.context.isLogin, true);
+    assert.equal(waitingSdk.context.isLogin, true);
+    assert.equal(waitingSdk.context.isReady, true);
+    assert.deepEqual(waitingSdk.context.loginUser, {
+      userId: 'user-1',
+      secretKey: 'secret-1',
+      sessionId: 'session-1',
+    });
+  } finally {
+    loggingInSdk.afterLogout();
+    waitingSdk.afterLogout();
+    loggingInSdk.tabSessionCoordinator.destroy();
+    waitingSdk.tabSessionCoordinator.destroy();
+  }
+});
+
+test('logout on one tab clears login state on sibling tabs without calling logout API again', async () => {
+  installBrowserMocks();
+
+  await patchDistTestImports(new URL('../dist-test/', import.meta.url));
+  const { default: ChatSDK } = await import('../dist-test/modules/ChatSDK.js');
+
+  const firstSdk = createSdk(ChatSDK);
+  firstSdk.context.deviceId = 'device-1';
+  firstSdk.context.isLogin = true;
+  firstSdk.context.isReady = true;
+  firstSdk.context.loginUser = {
+    userId: 'user-1',
+    secretKey: 'secret-1',
+    sessionId: 'session-1',
+  };
+
+  const secondSdk = createSdk(ChatSDK);
+  await new Promise((resolve) => setTimeout(resolve, 20));
+
+  assert.equal(secondSdk.context.isLogin, true);
+
+  let logoutApiCalls = 0;
+  firstSdk.httpClient.get = async (url) => {
+    if (url === '/user/logout') {
+      logoutApiCalls += 1;
+      return { ok: true, data: null };
+    }
+    return { ok: true, data: null };
+  };
+  secondSdk.httpClient.get = async (url) => {
+    if (url === '/user/logout') {
+      logoutApiCalls += 1;
+      return { ok: true, data: null };
+    }
+    return { ok: true, data: null };
+  };
+
+  try {
+    const res = await firstSdk.logout();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assert.equal(res.ok, true);
+    assert.equal(logoutApiCalls, 1);
+    assert.equal(firstSdk.context.isLogin, false);
+    assert.equal(firstSdk.context.isReady, false);
+    assert.equal(secondSdk.context.isLogin, false);
+    assert.equal(secondSdk.context.isReady, false);
+  } finally {
+    firstSdk.afterLogout();
+    secondSdk.afterLogout();
+    firstSdk.tabSessionCoordinator.destroy();
+    secondSdk.tabSessionCoordinator.destroy();
+  }
+});

package/test/tab-session-coordinator.test.mjs

@@ -53,54 +53,6 @@ function installBrowserMocks() {
   };
 }
 
-test('a new tab takeover request only notifies the old tab', async () => {
-  installBrowserMocks();
-
-  let oldTabKicked = 0;
-  let newTabKicked = 0;
-  const oldTab = new TabSessionCoordinator({
-    onTakeoverRequest: () => {
-      oldTabKicked += 1;
-    },
-  });
-  const newTab = new TabSessionCoordinator({
-    onTakeoverRequest: () => {
-      newTabKicked += 1;
-    },
-  });
-
-  newTab.requestTakeover();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-
-  assert.equal(oldTabKicked, 1);
-  assert.equal(newTabKicked, 0);
-
-  oldTab.destroy();
-  newTab.destroy();
-});
-
-test('destroyed coordinators ignore later takeover requests', async () => {
-  installBrowserMocks();
-
-  let oldTabKicked = 0;
-  const oldTab = new TabSessionCoordinator({
-    onTakeoverRequest: () => {
-      oldTabKicked += 1;
-    },
-  });
-  const newTab = new TabSessionCoordinator({
-    onTakeoverRequest: () => {},
-  });
-
-  oldTab.destroy();
-  newTab.requestTakeover();
-  await new Promise((resolve) => setTimeout(resolve, 0));
-
-  assert.equal(oldTabKicked, 0);
-
-  newTab.destroy();
-});
-
 test('a new tab can request the current login session from an old tab', async () => {
   installBrowserMocks();
 
@@ -114,11 +66,8 @@ test('a new tab can request the current login session from an old tab', async ()
   };
   const oldTab = new TabSessionCoordinator({
     getCurrentSession: () => session,
-    onTakeoverRequest: () => {},
-  });
-  const newTab = new TabSessionCoordinator({
-    onTakeoverRequest: () => {},
   });
+  const newTab = new TabSessionCoordinator({});
 
   const restoredSession = await newTab.requestCurrentSession(50);
 
@@ -141,11 +90,8 @@ test('login session responses are not persisted through localStorage', async ()
   };
   const oldTab = new TabSessionCoordinator({
     getCurrentSession: () => session,
-    onTakeoverRequest: () => {},
-  });
-  const newTab = new TabSessionCoordinator({
-    onTakeoverRequest: () => {},
   });
+  const newTab = new TabSessionCoordinator({});
 
   const restoredSession = await newTab.requestCurrentSession(50);
   const storedMessages = [...storageData.values()].map((value) =>
@@ -185,11 +131,8 @@ test('duplicate session requests from fallback channels are answered once', asyn
       sessionRequestCount += 1;
       return session;
     },
-    onTakeoverRequest: () => {},
-  });
-  const newTab = new TabSessionCoordinator({
-    onTakeoverRequest: () => {},
   });
+  const newTab = new TabSessionCoordinator({});
 
   await newTab.requestCurrentSession(50);
 
@@ -204,11 +147,8 @@ test('requesting a login session returns null when no tab is logged in', async (
 
   const oldTab = new TabSessionCoordinator({
     getCurrentSession: () => null,
-    onTakeoverRequest: () => {},
-  });
-  const newTab = new TabSessionCoordinator({
-    onTakeoverRequest: () => {},
   });
+  const newTab = new TabSessionCoordinator({});
 
   const restoredSession = await newTab.requestCurrentSession(1);
 
@@ -217,3 +157,64 @@ test('requesting a login session returns null when no tab is logged in', async (
   oldTab.destroy();
   newTab.destroy();
 });
+
+test('logout broadcast notifies other tabs once', async () => {
+  installBrowserMocks();
+
+  let oldTabLogout = 0;
+  let newTabLogout = 0;
+  const oldTab = new TabSessionCoordinator({
+    onLogoutBroadcast: () => {
+      oldTabLogout += 1;
+    },
+  });
+  const newTab = new TabSessionCoordinator({
+    onLogoutBroadcast: () => {
+      newTabLogout += 1;
+    },
+  });
+
+  newTab.publishLogout();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.equal(oldTabLogout, 1);
+  assert.equal(newTabLogout, 0);
+
+  oldTab.destroy();
+  newTab.destroy();
+});
+
+test('login broadcast notifies other tabs with session and does not persist secrets', async () => {
+  installBrowserMocks();
+
+  const session = {
+    deviceId: 'device-1',
+    loginUser: {
+      userId: 'user-1',
+      secretKey: 'secret-1',
+      sessionId: 'session-1',
+    },
+  };
+  /** @type {typeof session | null} */
+  let received = null;
+  const waitingTab = new TabSessionCoordinator({
+    onLoginBroadcast: (nextSession) => {
+      received = nextSession;
+    },
+  });
+  const loggingInTab = new TabSessionCoordinator({});
+
+  loggingInTab.publishLogin(session);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.deepEqual(received, session);
+  assert.equal(
+    [...storageData.values()].some((value) =>
+      JSON.stringify(value).includes('secret-1'),
+    ),
+    false,
+  );
+
+  waitingTab.destroy();
+  loggingInTab.destroy();
+});

package/test/websocket-url.test.mjs

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import { buildWebSocketConnectUrl } from '../dist-test/utils/websocket.js';
+
+test('buildWebSocketConnectUrl appends platform and deviceId-based ws_route', () => {
+  const url = buildWebSocketConnectUrl('wss://w-tx.typex-test.cn/ws', {
+    platform: 'web',
+    wsRoute: 'device-abc',
+  });
+
+  const parsed = new URL(url);
+  assert.equal(parsed.origin + parsed.pathname, 'wss://w-tx.typex-test.cn/ws');
+  assert.equal(parsed.searchParams.get('platform'), 'web');
+  assert.equal(parsed.searchParams.get('ws_route'), 'device-abc');
+});
+
+test('buildWebSocketConnectUrl uses empty ws_route when deviceId is missing', () => {
+  const url = buildWebSocketConnectUrl('wss://w-tx.typex-test.cn/ws', {
+    wsRoute: null,
+  });
+
+  assert.equal(new URL(url).searchParams.get('ws_route'), '');
+});

package/dist/types/modules/SingletonLock.d.ts

@@ -1,12 +0,0 @@
-export type SingletonLockRequestOptions = {
-    timeoutMs?: number;
-    retryIntervalMs?: number;
-};
-export default class SingletonLock {
-    private obtained;
-    private abortLockObtain;
-    constructor();
-    requestLock(options?: SingletonLockRequestOptions): Promise<boolean>;
-    private requestLockOnce;
-    releaseLock(): void;
-}