@proteinjs/user-server 1.22.1 → 1.22.3

package/test/SignupRoute.test.ts

@@ -35,7 +35,7 @@ jest.mock('@proteinjs/email-server', () => ({
 
 import { getDbAsSystem, Reference } from '@proteinjs/db';
 import { SourceRepository } from '@proteinjs/reflection';
-import { tables } from '@proteinjs/user';
+import { MachineAccount, tables } from '@proteinjs/user';
 import { signup } from '../src/routes/signup';
 import { createPassportRequest } from './passportSessionHarness';
 import { UserServerTestEnvironment } from './UserServerTestEnvironment';
@@ -45,6 +45,31 @@ const testEnv = new UserServerTestEnvironment();
 const INVITE_CONFIG_KEY = '@proteinjs/user-server/DefaultInviteConfigFactory';
 
 type ObjectCache = { objectCache: Record<string, unknown[]> };
+type NamedObjectCache = {
+  namedObjectCache: Record<string, { qualifiedName: string; packageName: string; object: unknown }[]>;
+};
+
+/** A code-declared machine account owning an address (the declaration only — never booted here). */
+class DeclaredMachineAccount extends MachineAccount {
+  id = 'declared-machine';
+  email = 'declared.machine@test.local';
+  accountName = 'Declared machine';
+  roles = [];
+  secretName = 'declared-machine-secret';
+}
+
+const LOADER_KEY = '@proteinjs/db/SourceRecordLoader';
+
+/** Seed the build's source-record declarations (the machine-account read resolves them by name). */
+const setDeclarations = (declarations: unknown[]) => {
+  (SourceRepository.get() as unknown as NamedObjectCache).namedObjectCache[LOADER_KEY] = declarations.map(
+    (object, i) => ({
+      qualifiedName: `@proteinjs/user-server-test/Declared${i}`,
+      packageName: '@test/declarer',
+      object,
+    })
+  );
+};
 
 /** Seed the invite-config lookup (tests don't load the generated source graph). */
 const setInviteConfig = (factories: unknown[]) => {
@@ -94,12 +119,14 @@ describe('signup route — auto-login after signup', () => {
   }, 120000);
 
   afterAll(async () => {
+    delete (SourceRepository.get() as unknown as NamedObjectCache).namedObjectCache[LOADER_KEY];
     await testEnv.afterAll();
   });
 
   beforeEach(async () => {
     jest.clearAllMocks();
     setInviteConfig([]);
+    setDeclarations([]);
     const db = getDbAsSystem();
     await db.delete(tables.Invite, {});
     await db.delete(tables.User, {});
@@ -180,6 +207,32 @@ describe('signup route — auto-login after signup', () => {
     expect(sendEmail).toHaveBeenCalledTimes(1); // "account already exists" email
   });
 
+  it(`an address a machine-account declaration owns can't be registered — by signup or by invite: plain words, no account, no session`, async () => {
+    setDeclarations([new DeclaredMachineAccount()]);
+
+    const direct = await invokeSignup({
+      name: 'Squatter',
+      email: 'Declared.Machine@test.local',
+      password: 'pw-squat-1',
+    });
+    expect(direct.body).toEqual({ error: "This address can't be registered." });
+    expect(direct.loggedInAs).toBeUndefined();
+    expect(direct.sessionEvents).toEqual([]);
+
+    await getDbAsSystem().insert(tables.Invite, {
+      email: 'declared.machine@test.local',
+      token: 'invite-token-declared',
+      tokenExpiresAt: moment().add(1, 'day'),
+      invitedBy: new Reference(tables.User.name, 'inviter-1'),
+    });
+    const invited = await invokeSignup({ name: 'Squatter', password: 'pw-squat-2', token: 'invite-token-declared' });
+    expect(invited.body).toEqual({ error: "This address can't be registered." });
+    expect(invited.loggedInAs).toBeUndefined();
+
+    expect(await getUserRow('declared.machine@test.local')).toBeUndefined();
+    expect(sendEmail).not.toHaveBeenCalled();
+  });
+
   it('an unknown invite token gets the honest error — no session, no account', async () => {
     const outcome = await invokeSignup({
       name: 'Token Guess',

package/test/SlidingWindow.test.ts

@@ -0,0 +1,85 @@
+import { SlidingWindow } from '../src/throttle/SlidingWindow';
+
+/**
+ * The per-key sliding window every throttled door shares (the sign-in and reset doors here, the
+ * invite-request door in the consuming app): `hit` records and answers whether the key is over,
+ * `isOver` only reads, `record` only counts, `clear` forgets. Attempts refused as over the window
+ * are not counted, so a key drains exactly one window after its last counted attempt.
+ */
+describe('SlidingWindow', () => {
+  const MINUTE = 60 * 1000;
+  let now = 1_700_000_000_000;
+  const clock = () => now;
+
+  it('admits up to the limit inside the window and refuses the next', () => {
+    const window = new SlidingWindow({ windowMs: 10 * MINUTE, limit: 3, now: clock });
+
+    expect([window.hit('a'), window.hit('a'), window.hit('a')]).toEqual([false, false, false]);
+    expect(window.hit('a')).toBe(true);
+    expect(window.isOver('a')).toBe(true);
+  });
+
+  it('keeps each key in its own window', () => {
+    const window = new SlidingWindow({ windowMs: 10 * MINUTE, limit: 2, now: clock });
+    window.hit('a');
+    window.hit('a');
+
+    expect(window.hit('a')).toBe(true);
+    expect(window.hit('b')).toBe(false);
+  });
+
+  it('drains: an attempt older than the window no longer counts, and refused attempts never counted', () => {
+    const window = new SlidingWindow({ windowMs: 10 * MINUTE, limit: 2, now: clock });
+    window.hit('a');
+    now += 4 * MINUTE;
+    window.hit('a');
+    now += 5 * MINUTE;
+    expect(window.hit('a')).toBe(true); // both counted attempts are still inside the window
+
+    now += 1 * MINUTE + 1; // the first counted attempt left the window; the refused one never counted
+    expect(window.hit('a')).toBe(false);
+    expect(window.hit('a')).toBe(true);
+  });
+
+  it('isOver reads without counting; record counts without answering; clear forgets the key', () => {
+    const window = new SlidingWindow({ windowMs: 10 * MINUTE, limit: 2, now: clock });
+
+    expect(window.isOver('a')).toBe(false);
+    expect(window.isOver('a')).toBe(false);
+    window.record('a');
+    expect(window.isOver('a')).toBe(false);
+    window.record('a');
+    expect(window.isOver('a')).toBe(true);
+
+    window.clear('a');
+    expect(window.isOver('a')).toBe(false);
+  });
+
+  it('forgive uncounts the latest attempt only', () => {
+    const window = new SlidingWindow({ windowMs: 10 * MINUTE, limit: 2, now: clock });
+    window.hit('a');
+    window.hit('a');
+    expect(window.isOver('a')).toBe(true);
+
+    window.forgive('a');
+
+    expect(window.isOver('a')).toBe(false);
+    expect(window.hit('a')).toBe(false);
+    expect(window.hit('a')).toBe(true);
+    window.forgive('b'); // a key never seen: nothing to uncount, nothing thrown
+    expect(window.isOver('b')).toBe(false);
+  });
+
+  it('bounds the keys it tracks: at the bound the oldest-touched key is forgotten first', () => {
+    const window = new SlidingWindow({ windowMs: 10 * MINUTE, limit: 1, maxKeys: 2, now: clock });
+    window.hit('a');
+    window.hit('b');
+    window.hit('a'); // refused, but 'a' is now the most recently touched
+
+    window.hit('c'); // at the bound: 'b' (oldest-touched) is forgotten
+
+    expect(window.isOver('a')).toBe(true);
+    expect(window.isOver('b')).toBe(false);
+    expect(window.isOver('c')).toBe(true);
+  });
+});

package/test/SocketIOSessionWatcher.test.ts

@@ -0,0 +1,86 @@
+import { createServer } from 'http';
+import { QueryBuilder } from '@proteinjs/db';
+import { SourceRepository } from '@proteinjs/reflection';
+import { SocketIOServerRepo } from '@proteinjs/server';
+import { Session } from '@proteinjs/user';
+import { SocketIOSessionWatcher } from '../src/authentication/SocketIOSessionWatcher';
+
+type ObjectCache = { objectCache: Record<string, unknown[]> };
+
+/** What the watcher asked the socket server to do: which rooms (session ids) it closed. */
+type DisconnectCall = { rooms: string[]; close: boolean };
+
+/**
+ * The socket server this file installs through the repo's own factory seam — a stand-in that
+ * records every `in(rooms).disconnectSockets(close)` it receives (no socket.io client is part of
+ * this package, so no real socket can connect to observe).
+ */
+class RecordingSocketIOServer {
+  readonly calls: DisconnectCall[] = [];
+
+  in(rooms: string | string[]) {
+    return {
+      disconnectSockets: (close: boolean) => {
+        this.calls.push({ rooms: ([] as string[]).concat(rooms), close });
+      },
+    };
+  }
+}
+
+const session = (sessionId: string): Session =>
+  ({ id: `row-${sessionId}`, sessionId, session: '{}', userEmail: 'someone@test.local' }) as unknown as Session;
+
+const deleteSessions = async (sessions: Session[]) =>
+  await new SocketIOSessionWatcher().afterDelete(
+    sessions.length,
+    sessions,
+    new QueryBuilder<Session>('session'),
+    new QueryBuilder<Session>('session')
+  );
+
+/**
+ * Deleting session rows closes their sockets — and a deletion is not always made by a running
+ * server: a boot's source-record sync (and a migration Job, which never starts one) deactivates a
+ * withdrawn machine account and deletes its sessions before any socket server exists.
+ */
+describe('SocketIOSessionWatcher', () => {
+  it('a deletion before the socket server exists resolves — no socket can be open yet', async () => {
+    expect(SocketIOServerRepo.getSocketIOServerIfExists()).toBeUndefined();
+
+    await expect(deleteSessions([session('before-boot')])).resolves.toBeUndefined();
+  });
+
+  describe('with the socket server up', () => {
+    const server = new RecordingSocketIOServer();
+
+    beforeAll(async () => {
+      (SourceRepository.get() as unknown as ObjectCache).objectCache['@proteinjs/event/DefaultSocketIOServerFactory'] =
+        [{ createSocketIOServer: async () => server }];
+      await SocketIOServerRepo.createSocketIOServer(createServer());
+    });
+
+    afterAll(() => {
+      delete (SourceRepository.get() as unknown as ObjectCache).objectCache[
+        '@proteinjs/event/DefaultSocketIOServerFactory'
+      ];
+    });
+
+    beforeEach(() => {
+      server.calls.length = 0;
+    });
+
+    it(`closes exactly the deleted sessions' sockets`, async () => {
+      await deleteSessions([session('s-1'), session('s-2')]);
+
+      expect(server.calls).toEqual([{ rooms: ['s-1', 's-2'], close: true }]);
+    });
+
+    it('a deletion with no session ids closes nothing — an empty room list would address every socket', async () => {
+      // socket.io's in-memory adapter applies an operation with NO rooms to every socket on the
+      // namespace (`apply`: `if (rooms.size) … else for every sid`), so `in([])` must never be sent.
+      await deleteSessions([]);
+
+      expect(server.calls).toEqual([]);
+    });
+  });
+});

package/test/setup.js

@@ -1,2 +1,4 @@
 process.env.SPANNER_EMULATOR_HOST = process.env.SPANNER_EMULATOR_HOST || 'localhost:9010';
 process.env.DB_LOG_LEVEL = 'error';
+// The key the throttled doors' digests (RequestDigests) derive from; a process without one refuses to digest.
+process.env.SESSION_SECRET = process.env.SESSION_SECRET || 'user-server-test-secret';