@typexim/web-sdk 0.0.6 → 0.0.8-alpha.1

package/test/chat-sdk-independent-login.test.mjs

@@ -0,0 +1,218 @@
+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: () => {},
+    removeEventListener: () => {},
+  };
+  globalThis.localStorage = {
+    getItem: (key) => storageData.get(key) ?? null,
+    setItem: (key, value) => {
+      storageData.set(key, 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('two SDK instances can login independently 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 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',
+      };
+    }
+
+    if (url === '/user/session/login') {
+      sessionLoginCalls += 1;
+      return {
+        ok: true,
+        data: {
+          id: `user-${body.userCode}`,
+          key: `secret-${body.userCode}`,
+        },
+      };
+    }
+
+    return {
+      ok: false,
+      code: -1,
+      msg: `unexpected post ${url}`,
+    };
+  };
+
+  firstSdk.httpClient.post = mockPost;
+  secondSdk.httpClient.post = mockPost;
+
+  try {
+    // 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' });
+    const secondRes = await secondSdk.login({ user_code: 'code-a' });
+
+    assert.equal(firstRes.ok, true);
+    assert.equal(secondRes.ok, true);
+    assert.equal(sessionLoginCalls, 2);
+    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 {
+    firstSdk.afterLogout();
+    secondSdk.afterLogout();
+    firstSdk.tabSessionCoordinator.destroy();
+    secondSdk.tabSessionCoordinator.destroy();
+  }
+});

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

@@ -47,25 +47,9 @@ 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;
@@ -177,7 +161,7 @@ async function patchRelativeImports(source, sourceUrl) {
   return patched;
 }
 
-test('login restores an active tab session before calling session login API', async () => {
+test('new tab restores neighbor session without login API and without kicking neighbor', async () => {
   installBrowserMocks();
 
   await patchDistTestImports(new URL('../dist-test/', import.meta.url));
@@ -192,10 +176,9 @@ test('login restores an active tab session before calling session login API', as
     secretKey: 'secret-1',
     sessionId: 'session-1',
   };
-  await oldSdk.singletonLock.requestLock();
 
-  const newSdk = createSdk(ChatSDK);
   let sessionLoginApiCalled = false;
+  const newSdk = createSdk(ChatSDK);
   newSdk.httpClient.post = async (url) => {
     if (url === '/user/session/login') {
       sessionLoginApiCalled = true;
@@ -208,25 +191,82 @@ test('login restores an active tab session before calling session login API', as
   };
 
   try {
-    const res = await newSdk.login({
-      user_code: 'session-1',
-    });
+    // Wait for auto-restore scheduled in init.
+    await new Promise((resolve) => setTimeout(resolve, 20));
 
-    assert.equal(res.ok, true);
-    assert.equal(sessionLoginApiCalled, false);
     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, false);
-    assert.equal(oldSdk.context.isReady, false);
+    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 {
-    await oldSdk.afterLogout();
-    await newSdk.afterLogout();
+    oldSdk.afterLogout();
+    newSdk.afterLogout();
     oldSdk.tabSessionCoordinator.destroy();
     newSdk.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,29 @@ 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();
+});

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;
-}

package/test/singleton-lock.test.mjs

@@ -1,75 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import SingletonLock from '../dist-test/modules/SingletonLock.js';
-
-function installMockLocks(sequence) {
-  let callIndex = 0;
-  Object.defineProperty(globalThis, 'navigator', {
-    configurable: true,
-    value: {
-      locks: {
-        request: (_name, _options, callback) => {
-          const available = sequence[Math.min(callIndex, sequence.length - 1)];
-          callIndex += 1;
-          Promise.resolve().then(() => callback(available ? {} : null));
-        },
-      },
-    },
-  });
-}
-
-function installNavigator(value) {
-  Object.defineProperty(globalThis, 'navigator', {
-    configurable: true,
-    value,
-  });
-}
-
-test('requestLock retries until an old tab releases the singleton lock', async () => {
-  installMockLocks([false, false, true]);
-
-  const lock = new SingletonLock();
-  const obtained = await lock.requestLock({
-    retryIntervalMs: 1,
-    timeoutMs: 50,
-  });
-
-  assert.equal(obtained, true);
-});
-
-test('requestLock gives up when the old tab does not release in time', async () => {
-  installMockLocks([false]);
-
-  const lock = new SingletonLock();
-  const obtained = await lock.requestLock({
-    retryIntervalMs: 1,
-    timeoutMs: 5,
-  });
-
-  assert.equal(obtained, false);
-});
-
-test('requestLock fails closed when Web Locks is unavailable', async () => {
-  installNavigator({});
-
-  const lock = new SingletonLock();
-  const obtained = await lock.requestLock();
-
-  assert.equal(obtained, false);
-});
-
-test('requestLock fails closed when Web Locks throws', async () => {
-  installNavigator({
-    locks: {
-      request: () => {
-        throw new Error('locks unavailable');
-      },
-    },
-  });
-
-  const lock = new SingletonLock();
-  const obtained = await lock.requestLock();
-
-  assert.equal(obtained, false);
-});