snapshot of https://github.com/toeverything/AFFiNE.git (canary, 2026-09-16; blobs > 131072B omitted)

packages/common/infra/src/utils/__tests__/async-lock.spec.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from 'vitest';
+
+import { AsyncLock } from '../async-lock';
+
+describe('AsyncLock', () => {
+  test('should acquire and release lock', async () => {
+    const lock = new AsyncLock();
+    const lock1 = await lock.acquire();
+    lock1.release();
+  });
+
+  test('should wait for previous lock to be released', async () => {
+    const lock = new AsyncLock();
+    const order: number[] = [];
+
+    const task1 = async () => {
+      const lock1 = await lock.acquire();
+      order.push(1);
+      await new Promise(resolve => setTimeout(resolve, 10));
+      order.push(2);
+      lock1.release();
+    };
+
+    const task2 = async () => {
+      const lock2 = await lock.acquire();
+      order.push(3);
+      lock2.release();
+    };
+
+    await Promise.all([task1(), task2()]);
+    expect(order).toEqual([1, 2, 3]);
+  });
+
+  test('should work with using statement', async () => {
+    const lock = new AsyncLock();
+    const order: number[] = [];
+
+    const task1 = async () => {
+      using _lock1 = await lock.acquire();
+      order.push(1);
+      await new Promise(resolve => setTimeout(resolve, 10));
+      order.push(2);
+    };
+
+    const task2 = async () => {
+      using _lock2 = await lock.acquire();
+      order.push(3);
+    };
+
+    await Promise.all([task1(), task2()]);
+    expect(order).toEqual([1, 2, 3]);
+  });
+
+  test('should handle multiple concurrent locks', async () => {
+    const lock = new AsyncLock();
+    const results: number[] = [];
+
+    const createTask = (id: number, delay: number) => async () => {
+      using _lockHandle = await lock.acquire();
+      results.push(id);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    };
+
+    await Promise.all([
+      createTask(1, 20)(),
+      createTask(2, 10)(),
+      createTask(3, 5)(),
+    ]);
+
+    expect(results).toEqual([1, 2, 3]);
+  });
+
+  test('should properly block after a release', async () => {
+    const lock = new AsyncLock();
+    const order: number[] = [];
+
+    // First acquisition
+    const lock1 = await lock.acquire();
+    order.push(1);
+    lock1.release();
+
+    // These two should be properly serialized
+    const task1 = async () => {
+      const lock2 = await lock.acquire();
+      order.push(2);
+      await new Promise(resolve => setTimeout(resolve, 10));
+      order.push(3);
+      lock2.release();
+    };
+
+    const task2 = async () => {
+      const lock3 = await lock.acquire();
+      order.push(4);
+      lock3.release();
+    };
+
+    await Promise.all([task1(), task2()]);
+    expect(order).toEqual([1, 2, 3, 4]); // This might fail due to the bug
+  });
+
+  test('should prevent multiple releases', async () => {
+    const lock = new AsyncLock();
+    const handle = await lock.acquire();
+    handle.release();
+
+    // This second release should either throw or be a no-op
+    handle.release();
+
+    // The lock should still be usable
+    const handle2 = await lock.acquire();
+    handle2.release();
+  });
+});

packages/common/infra/src/utils/__tests__/async-queue.spec.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test, vi } from 'vitest';
+
+import { AsyncQueue } from '../async-queue';
+
+describe('async-queue', () => {
+  test('push & pop', async () => {
+    const queue = new AsyncQueue();
+    queue.push(1, 2, 3);
+    expect(queue.length).toBe(3);
+    expect(await queue.next()).toBe(1);
+    expect(await queue.next()).toBe(2);
+    expect(await queue.next()).toBe(3);
+    expect(queue.length).toBe(0);
+  });
+
+  test('await', async () => {
+    const queue = new AsyncQueue<number>();
+    queue.push(1, 2);
+    expect(await queue.next()).toBe(1);
+    expect(await queue.next()).toBe(2);
+
+    let v = -1;
+
+    // setup 2 pop tasks
+    queue
+      .next()
+      .then(next => {
+        v = next;
+      })
+      .catch(console.error);
+    queue
+      .next()
+      .then(next => {
+        v = next;
+      })
+      .catch(console.error);
+
+    // Wait for 100ms
+    await new Promise(resolve => setTimeout(resolve, 100));
+    // v should not be changed
+    expect(v).toBe(-1);
+
+    // push 3, should trigger the first pop task
+    queue.push(3);
+    await vi.waitFor(() => v === 3);
+
+    // push 4, should trigger the second pop task
+    queue.push(4);
+    await vi.waitFor(() => v === 4);
+  });
+});

packages/common/infra/src/utils/__tests__/fractional-indexing.spec.ts

@@ -0,0 +1,74 @@
+import { expect, test } from 'vitest';
+
+import { generateFractionalIndexingKeyBetween } from '../fractional-indexing';
+
+function gen(a: string | null, b: string | null) {
+  const result = generateFractionalIndexingKeyBetween(a, b);
+
+  expect(
+    a === null || b === null || (a < result && result < b),
+    `${a} ${b} ${result}`
+  ).toBe(true);
+  return result;
+}
+
+test('fractional-indexing', () => {
+  for (let i = 0; i < 100; i++) {
+    const set = new Set<string>();
+    let a = null;
+    let b = null;
+    for (let i = 0; i < 100; i++) {
+      const s1 = gen(a, b);
+      expect(a === null || b === null || (a < s1 && s1 < b)).toBe(true);
+      const s2 = gen(a, b);
+      expect(a === null || b === null || (a < s2 && s2 < b)).toBe(true);
+
+      if (set.has(s1) || set.has(s2) || s1 === s2) {
+        throw new Error('Duplicate key, ' + set.size + ', ' + s1 + ', ' + s2);
+      }
+      set.add(s1);
+      set.add(s2);
+      if (s1 < s2) {
+        a = s1;
+        b = s2;
+      } else {
+        a = s2;
+        b = s1;
+      }
+    }
+  }
+});
+
+test('no postfix', () => {
+  expect(
+    generateFractionalIndexingKeyBetween('a0', null).startsWith('a1')
+  ).toBe(true);
+  expect(
+    generateFractionalIndexingKeyBetween('a01', null).startsWith('a1')
+  ).toBe(true);
+  expect(
+    generateFractionalIndexingKeyBetween('a0001', null).startsWith('a1')
+  ).toBe(true);
+  expect(
+    generateFractionalIndexingKeyBetween(null, 'a0').startsWith('Zz')
+  ).toBe(true);
+  expect(
+    generateFractionalIndexingKeyBetween('a0', 'a01').startsWith('a00V')
+  ).toBe(true);
+});
+
+test('edge cases', () => {
+  for (let i = 0; i < 100; i++) {
+    let a = generateFractionalIndexingKeyBetween(null, null);
+    let b = generateFractionalIndexingKeyBetween(null, null);
+    if (a > b) {
+      [a, b] = [b, a];
+    }
+    const c = generateFractionalIndexingKeyBetween(a, b);
+    const d = generateFractionalIndexingKeyBetween(c, b);
+    expect(a < c).toBeTruthy();
+    expect(c < b).toBeTruthy();
+    expect(c < d).toBeTruthy();
+    expect(d < b).toBeTruthy();
+  }
+});

packages/common/infra/src/utils/__tests__/redirect-allowlist.spec.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'vitest';
+
+import { isAllowedRedirectTarget } from '../redirect-allowlist';
+
+describe('redirect allowlist', () => {
+  test('allows same hostname', () => {
+    expect(
+      isAllowedRedirectTarget('https://self.example.com/path', {
+        currentHostname: 'self.example.com',
+      })
+    ).toBe(true);
+  });
+
+  test('allows trusted domains and subdomains', () => {
+    expect(
+      isAllowedRedirectTarget('https://github.com/toeverything/AFFiNE', {
+        currentHostname: 'self.example.com',
+      })
+    ).toBe(true);
+
+    expect(
+      isAllowedRedirectTarget('https://sub.github.com/foo', {
+        currentHostname: 'self.example.com',
+      })
+    ).toBe(true);
+  });
+
+  test('blocks look-alike domains', () => {
+    expect(
+      isAllowedRedirectTarget('https://evilgithub.com', {
+        currentHostname: 'self.example.com',
+      })
+    ).toBe(false);
+  });
+
+  test('blocks disallowed protocols', () => {
+    expect(
+      isAllowedRedirectTarget('javascript:alert(1)', {
+        currentHostname: 'self.example.com',
+      })
+    ).toBe(false);
+  });
+
+  test('handles port and trailing dot', () => {
+    expect(
+      isAllowedRedirectTarget('https://github.com:8443', {
+        currentHostname: 'self.example.com',
+      })
+    ).toBe(true);
+
+    expect(
+      isAllowedRedirectTarget('https://affine.pro./', {
+        currentHostname: 'self.example.com',
+      })
+    ).toBe(true);
+  });
+
+  test('blocks punycode homograph', () => {
+    // "а" is Cyrillic small a (U+0430), different from Latin "a"
+    expect(
+      isAllowedRedirectTarget('https://аffine.pro', {
+        currentHostname: 'self.example.com',
+      })
+    ).toBe(false);
+  });
+});

packages/common/infra/src/utils/__tests__/throw-if-aborted.spec.ts

@@ -0,0 +1,13 @@
+import { describe, expect, test } from 'vitest';
+
+import { throwIfAborted } from '../throw-if-aborted';
+
+describe('throw-if-aborted', () => {
+  test('basic', async () => {
+    const abortController = new AbortController();
+    const abortSignal = abortController.signal;
+    expect(throwIfAborted(abortSignal)).toBe(true);
+    abortController.abort('TEST_ABORT');
+    expect(() => throwIfAborted(abortSignal)).toThrowError('TEST_ABORT');
+  });
+});

packages/common/infra/src/utils/__tests__/yjs-observable.spec.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from 'vitest';
+import { Array as YArray, Doc as YDoc, Map as YMap } from 'yjs';
+
+import { yjsGetPath, yjsObservePath } from '../yjs-observable';
+
+describe('yjs observable', () => {
+  test('basic', async () => {
+    const ydoc = new YDoc();
+    let currentValue: any = false;
+    yjsGetPath(ydoc.getMap('foo'), 'key.subkey').subscribe(
+      v => (currentValue = v)
+    );
+    expect(currentValue).toBe(undefined);
+
+    ydoc.getMap('foo').set('key', new YMap([['subkey', 'xxxzzz']]));
+    expect(currentValue).toBe('xxxzzz');
+
+    (ydoc.getMap('foo').get('key') as YMap<string>).set('subkey', 'yyy');
+    expect(currentValue).toBe('yyy');
+
+    (ydoc.getMap('foo').get('key') as YMap<string>).delete('subkey');
+    expect(currentValue).toBe(undefined);
+
+    (ydoc.getMap('foo').get('key') as YMap<string>).set('subkey', 'yyy');
+    ydoc.getMap('foo').delete('key');
+    expect(currentValue).toBe(undefined);
+
+    ydoc.getMap('foo').set('key', 'text');
+    expect(currentValue).toBe(undefined);
+  });
+
+  test('observe with path', async () => {
+    const ydoc = new YDoc();
+
+    /**
+     * {
+     *   metas: {
+     *     pages: [
+     *       {
+     *         id: '1',
+     *         title: 'page 1',
+     *         tags: ['tag1', 'tag2']
+     *       }
+     *     ]
+     *   }
+     * }
+     */
+
+    let currentValue: any = false;
+    let callbackCount = 0;
+
+    yjsObservePath(ydoc.getMap('metas'), 'pages.*.tags').subscribe(v => {
+      callbackCount++;
+      currentValue = (v as any)
+        .toJSON()
+        .pages?.map((page: any) => ({ id: page.id, tags: page.tags ?? [] }));
+    });
+
+    expect(callbackCount).toBe(1);
+
+    ydoc.getMap('metas').set('pages', new YArray<any>());
+
+    expect(callbackCount).toBe(2);
+    expect(currentValue).toStrictEqual([]);
+
+    const pages = ydoc.getMap('metas').get('pages') as YArray<any>;
+    pages.push([
+      new YMap([
+        ['id', '1'],
+        ['title', 'page 1'],
+        ['tags', YArray.from(['tag1', 'tag2'])],
+      ]),
+    ]);
+
+    expect(callbackCount).toBe(3);
+    expect(currentValue).toStrictEqual([{ id: '1', tags: ['tag1', 'tag2'] }]);
+
+    pages.get(0).set('title', 'page 1*');
+
+    expect(callbackCount).toBe(3); // no change
+
+    pages.get(0).get('tags').push(['tag3']);
+
+    expect(callbackCount).toBe(4);
+    expect(currentValue).toStrictEqual([
+      { id: '1', tags: ['tag1', 'tag2', 'tag3'] },
+    ]);
+
+    ydoc.getMap('metas').set('otherMeta', 'true');
+
+    expect(callbackCount).toBe(4); // no change
+
+    pages.push([
+      new YMap([
+        ['id', '2'],
+        ['title', 'page 2'],
+      ]),
+    ]);
+
+    expect(callbackCount).toBe(5);
+    expect(currentValue).toStrictEqual([
+      { id: '1', tags: ['tag1', 'tag2', 'tag3'] },
+      { id: '2', tags: [] },
+    ]);
+
+    pages.delete(0);
+
+    expect(callbackCount).toBe(6);
+    expect(currentValue).toStrictEqual([{ id: '2', tags: [] }]);
+  });
+});