Skip to content

TaskView is a self-hosted project and task management platform focused on clarity, ownership, and control. TaskView is built for teams that want a transparent, self-hosted alternative to SaaS task managers.

3.2 KB
Raw Blame
import { and, eq, gt, ne, sql } from 'drizzle-orm'
import { UserTokensSchema } from 'taskview-db-schemas'
import { Database } from '../../modules/db'
import { callWithCatch, parseDeviceName, parsePositiveInt } from '../../utils/helpers'

const DEFAULT_SESSION_MAX_AGE_DAYS = 90

export default class SessionStorage {
  private readonly db: Database

  /** A session ends this many days after sign-in, however often its tokens are refreshed. */
  static maxAgeDays(): number {
    return parsePositiveInt(process.env.SESSION_MAX_AGE_DAYS) ?? DEFAULT_SESSION_MAX_AGE_DAYS
  }

  static validateOnStartup(): void {
    const raw = process.env.SESSION_MAX_AGE_DAYS
    if (raw !== undefined && raw.trim() !== '' && parsePositiveInt(raw) === null) {
      throw new Error(`SESSION_MAX_AGE_DAYS has unrecognized value "${raw}". Expected a positive integer`)
    }
  }

  private notExpired() {
    return gt(UserTokensSchema.timeCreation, sql`now() - make_interval(days => ${SessionStorage.maxAgeDays()})`)
  }

  constructor() {
    this.db = Database.getInstance()
  }

  async createSession(userId: number, ip: string | undefined, userAgent: string | undefined): Promise<number | false> {
    const deviceName = parseDeviceName(userAgent)
    const result = await callWithCatch(() =>
      this.db.dbDrizzle.insert(UserTokensSchema).values({
        userId,
        userIp: ip || null,
        deviceName,
        userAgent: userAgent || null,
        lastUsedAt: new Date(),
      }).returning({ id: UserTokensSchema.id })
    )
    return result?.[0]?.id ?? false
  }

  async isSessionActive(sessionId: number): Promise<boolean> {
    const result = await callWithCatch(() =>
      this.db.dbDrizzle.select({ id: UserTokensSchema.id })
        .from(UserTokensSchema)
        .where(and(eq(UserTokensSchema.id, sessionId), this.notExpired()))
    )
    return !!(result && result.length > 0)
  }

  async updateLastUsed(sessionId: number): Promise<void> {
    await callWithCatch(() =>
      this.db.dbDrizzle.update(UserTokensSchema)
        .set({ lastUsedAt: new Date() })
        .where(eq(UserTokensSchema.id, sessionId))
    )
  }

  async deleteSession(sessionId: number, userId: number): Promise<boolean> {
    const result = await callWithCatch(() =>
      this.db.dbDrizzle.delete(UserTokensSchema)
        .where(and(eq(UserTokensSchema.id, sessionId), eq(UserTokensSchema.userId, userId)))
    )
    return !!result?.rowCount
  }

  async deleteAllSessions(userId: number, excludeSessionId?: number): Promise<boolean> {
    if (excludeSessionId) {
      const result = await callWithCatch(() =>
        this.db.dbDrizzle.delete(UserTokensSchema)
          .where(and(
            eq(UserTokensSchema.userId, userId),
            ne(UserTokensSchema.id, excludeSessionId)
          ))
      )
      return !!result
    }

    const result = await callWithCatch(() =>
      this.db.dbDrizzle.delete(UserTokensSchema)
        .where(eq(UserTokensSchema.userId, userId))
    )
    return !!result
  }

  async fetchUserSessions(userId: number) {
    const result = await callWithCatch(() =>
      this.db.dbDrizzle.select()
        .from(UserTokensSchema)
        .where(and(eq(UserTokensSchema.userId, userId), this.notExpired()))
        .orderBy(UserTokensSchema.lastUsedAt)
    )
    return result ?? []
  }
}