@chidchanun/bcp 0.2.4 → 0.2.6

package/packages/server/src/auth-session-store.ts

@@ -0,0 +1,318 @@
+export interface AuthSessionStoreRecord {
+    sid: string;
+    userId: string;
+    createdAt: number;
+    expiresAt: number;
+    lastSeenAt: number;
+    revokedAt?: number | null;
+}
+
+export interface AuthSessionStore {
+    set(
+        record: AuthSessionStoreRecord
+    ): Promise<void> | void;
+    get(
+        sid: string
+    ): Promise<AuthSessionStoreRecord | null> | AuthSessionStoreRecord | null;
+    touch(
+        sid: string,
+        lastSeenAt: number
+    ): Promise<void> | void;
+    revoke(
+        sid: string,
+        revokedAt?: number
+    ): Promise<boolean> | boolean;
+    revokeUser(
+        userId: string,
+        revokedAt?: number
+    ): Promise<number> | number;
+}
+
+export interface MemoryAuthSessionStore
+extends AuthSessionStore {
+    clearExpired(
+        now?: number
+    ): number;
+    size(): number;
+}
+
+export function createMemoryAuthSessionStore(): MemoryAuthSessionStore {
+    const sessions =
+        new Map<
+            string,
+            AuthSessionStoreRecord
+        >();
+
+    const clearExpired = (
+        now = currentUnixTime()
+    ): number => {
+        let removed = 0;
+
+        for (
+            const [
+                sid,
+                record,
+            ]
+            of sessions
+        ) {
+            if (
+                record.expiresAt <= now
+            ) {
+                sessions.delete(
+                    sid
+                );
+                removed += 1;
+            }
+        }
+
+        return removed;
+    };
+
+    return {
+        set(record) {
+            assertRecord(
+                record
+            );
+            clearExpired();
+
+            sessions.set(
+                record.sid,
+                cloneRecord(
+                    record
+                )
+            );
+        },
+
+        get(sid) {
+            assertSid(
+                sid
+            );
+            clearExpired();
+
+            const record =
+                sessions.get(
+                    sid
+                );
+
+            return record
+                ? cloneRecord(
+                    record
+                )
+                : null;
+        },
+
+        touch(
+            sid,
+            lastSeenAt
+        ) {
+            assertSid(
+                sid
+            );
+            assertTimestamp(
+                lastSeenAt,
+                "lastSeenAt"
+            );
+            clearExpired(
+                lastSeenAt
+            );
+
+            const record =
+                sessions.get(
+                    sid
+                );
+
+            if (
+                !record ||
+                record.revokedAt !== undefined &&
+                record.revokedAt !== null
+            ) {
+                return;
+            }
+
+            record.lastSeenAt =
+                Math.max(
+                    record.lastSeenAt,
+                    lastSeenAt
+                );
+        },
+
+        revoke(
+            sid,
+            revokedAt = currentUnixTime()
+        ) {
+            assertSid(
+                sid
+            );
+            assertTimestamp(
+                revokedAt,
+                "revokedAt"
+            );
+
+            const record =
+                sessions.get(
+                    sid
+                );
+
+            if (!record) {
+                return false;
+            }
+
+            record.revokedAt =
+                revokedAt;
+
+            return true;
+        },
+
+        revokeUser(
+            userId,
+            revokedAt = currentUnixTime()
+        ) {
+            assertUserId(
+                userId
+            );
+            assertTimestamp(
+                revokedAt,
+                "revokedAt"
+            );
+            clearExpired(
+                revokedAt
+            );
+
+            let revoked = 0;
+
+            for (
+                const record
+                of sessions.values()
+            ) {
+                if (
+                    record.userId !== userId ||
+                    record.revokedAt !== undefined &&
+                    record.revokedAt !== null
+                ) {
+                    continue;
+                }
+
+                record.revokedAt =
+                    revokedAt;
+                revoked += 1;
+            }
+
+            return revoked;
+        },
+
+        clearExpired,
+
+        size() {
+            clearExpired();
+            return sessions.size;
+        },
+    };
+}
+
+function cloneRecord(
+    record: AuthSessionStoreRecord
+): AuthSessionStoreRecord {
+    return {
+        ...record,
+    };
+}
+
+function assertRecord(
+    record: AuthSessionStoreRecord
+): void {
+    if (
+        !record ||
+        typeof record !== "object"
+    ) {
+        throw new TypeError(
+            "BCP Auth Store: session record must be an object."
+        );
+    }
+
+    assertSid(
+        record.sid
+    );
+    assertUserId(
+        record.userId
+    );
+    assertTimestamp(
+        record.createdAt,
+        "createdAt"
+    );
+    assertTimestamp(
+        record.expiresAt,
+        "expiresAt"
+    );
+    assertTimestamp(
+        record.lastSeenAt,
+        "lastSeenAt"
+    );
+
+    if (
+        record.expiresAt <=
+        record.createdAt
+    ) {
+        throw new TypeError(
+            "BCP Auth Store: expiresAt must be later than createdAt."
+        );
+    }
+
+    if (
+        record.revokedAt !== undefined &&
+        record.revokedAt !== null
+    ) {
+        assertTimestamp(
+            record.revokedAt,
+            "revokedAt"
+        );
+    }
+}
+
+function assertSid(
+    value: string
+): void {
+    if (
+        typeof value !== "string" ||
+        value.trim() === ""
+    ) {
+        throw new TypeError(
+            "BCP Auth Store: sid must be a non-empty string."
+        );
+    }
+}
+
+function assertUserId(
+    value: string
+): void {
+    if (
+        typeof value !== "string" ||
+        value.trim() === ""
+    ) {
+        throw new TypeError(
+            "BCP Auth Store: userId must be a non-empty string."
+        );
+    }
+}
+
+function assertTimestamp(
+    value: number,
+    label: string
+): void {
+    if (
+        !Number.isFinite(
+            value
+        ) ||
+        value < 0
+    ) {
+        throw new TypeError(
+            `BCP Auth Store: ${label} must be a non-negative finite Unix timestamp.`
+        );
+    }
+}
+
+function currentUnixTime(): number {
+    return Math.floor(
+        Date.now() /
+        1000
+    );
+}