@codeclimbers/server 0.0.1

package/src/types/activities.api.d.ts

@@ -0,0 +1,18 @@
+declare namespace CodeClimbers {
+  export interface WakatimePulseStatusDao {
+    project: string
+    language: string
+    editor: string
+    operatingSystem: string
+    machine: string
+    branch: string
+    seconds: number | string
+    maxHeartbeatTime: string
+    minHeartbeatTime: string
+  }
+
+  export interface Source {
+    name: string
+    lastActive: string
+  }
+}

package/src/types/time.api.d.ts

@@ -0,0 +1,23 @@
+declare namespace CodeClimbers {
+  export interface WeekOverview {
+    longestDayMinutes: number
+    yesterdayMinutes: number
+    todayMinutes: number
+    weekMinutes: number
+  }
+
+  export interface WeekOverviewDao {
+    message: string
+    data: WeekOverview
+  }
+
+  export interface TimeOverview {
+    category: string
+    minutes: number
+  }
+
+  export interface TimeOverviewDao {
+    message: string
+    data: TimeOverview[]
+  }
+}

package/src/types/utils.d.ts

@@ -0,0 +1,8 @@
+declare namespace CodeClimbers {
+  export interface StartupService {
+    enableStartup: () => Promise<void>
+    disableStartup: () => Promise<void>
+    launchAndEnableStartup: () => Promise<void>
+    closeAndDisableStartup: () => Promise<void>
+  }
+}

package/src/types/wakatimeProxy.api.d.ts

@@ -0,0 +1,55 @@
+declare namespace CodeClimbers {
+  interface ActivitiesDetail {
+    digital: string
+    hours: number
+    minutes: number
+    name?: string
+    percent?: number
+    seconds?: number
+    text: string
+    total_seconds: number
+  }
+  export interface ActivitiesStatusBarData {
+    categories?: ActivitiesDetail[]
+    dependencies?: ActivitiesDetail[]
+    editors?: ActivitiesDetail[]
+    languages?: ActivitiesDetail[]
+    machines?: ActivitiesDetail[]
+    operating_systems?: ActivitiesDetail[]
+    projects?: ActivitiesDetail[]
+    branches?: ActivitiesDetail[] | null
+    entities?: ActivitiesDetail[] | null
+    grand_total?: ActivitiesDetail
+    range?: {
+      date: string
+      end: string
+      start: string
+      text: string
+      timezone: string
+    }
+  }
+  export interface ActivitiesStatusBar {
+    cached_at: string
+    data: ActivitiesStatusBarData
+  }
+
+  export interface CreateWakatimePulseDto {
+    userId?: string
+    entity: string
+    type: string
+    category?: string
+    project: string
+    branch: string
+    language?: string
+    is_write?: boolean
+    editor?: string
+    operating_system?: string
+    machine?: string
+    user_agent?: string
+    time: number | string
+    hash?: string
+    origin?: string
+    origin_id?: string
+    description?: string
+  }
+}

package/src/v1/activities/activities.service.ts

@@ -0,0 +1,213 @@
+import { Injectable } from '@nestjs/common'
+import { CreateWakatimePulseDto } from '../dtos/createWakatimePulse.dto'
+import activitiesUtil from '../../../utils/activities.util'
+import { PulseRepo } from '../database/pulse.repo'
+import * as os from 'node:os'
+import * as dayjs from 'dayjs'
+
+@Injectable()
+export class ActivitiesService {
+  constructor(private readonly pulseRepo: PulseRepo) {
+    this.pulseRepo = pulseRepo
+  }
+  async getActivityStatusBar(): Promise<CodeClimbers.ActivitiesStatusBar> {
+    const statusBarRaw = await this.pulseRepo.getStatusBarDetails()
+    return activitiesUtil.mapStatusBarRawToDto(statusBarRaw)
+  }
+  // process the pulse
+  async createPulse(pulseDto: CreateWakatimePulseDto) {
+    const latestProject = await this.pulseRepo.getLatestProject()
+    const pulse: CodeClimbers.Pulse = this.mapDtoToPulse(
+      pulseDto,
+      latestProject,
+    )
+    await this.pulseRepo.createPulse(pulse)
+    return activitiesUtil.pulseSuccessResponse(1)
+  }
+
+  async createPulses(pulsesDto: CreateWakatimePulseDto[]) {
+    const latestProject = await this.pulseRepo.getLatestProject()
+    const pulses: CodeClimbers.Pulse[] = pulsesDto.map((dto) =>
+      this.mapDtoToPulse(dto, latestProject),
+    )
+    const uniquePulses = activitiesUtil.filterUniqueByHash(pulses)
+
+    await this.pulseRepo.createPulses(uniquePulses)
+    return activitiesUtil.pulseSuccessResponse(pulsesDto.length)
+  }
+
+  async getLatestPulses(): Promise<CodeClimbers.Pulse[] | undefined> {
+    return this.pulseRepo.getLatestPulses()
+  }
+
+  async getCategoryTimeOverview(
+    startDate: string,
+    endDate: string,
+  ): Promise<CodeClimbers.TimeOverview[]> {
+    return await this.pulseRepo.getCategoryTimeOverview(startDate, endDate)
+  }
+
+  async getWeekOverview(date: string): Promise<CodeClimbers.WeekOverview> {
+    const currentDate = new Date(date)
+    const weekStart = new Date(
+      new Date(currentDate).setDate(currentDate.getDate() - 7),
+    )
+
+    const tomorrow = new Date(new Date(date).setDate(currentDate.getDate() + 1))
+
+    const yesterday = new Date(
+      new Date(date).setDate(currentDate.getDate() - 1),
+    )
+
+    const longestDayMinutes = await this.pulseRepo.getLongestDayInRangeMinutes(
+      weekStart,
+      currentDate,
+    )
+    const yesterdayMinutes = await this.pulseRepo.getRangeMinutes(
+      yesterday,
+      currentDate,
+    )
+    const todayMinutes = await this.pulseRepo.getRangeMinutes(
+      currentDate,
+      tomorrow,
+    )
+    const weekMinutes = await this.pulseRepo.getRangeMinutes(
+      weekStart,
+      currentDate,
+    )
+
+    return {
+      longestDayMinutes,
+      yesterdayMinutes,
+      todayMinutes,
+      weekMinutes,
+    }
+  }
+
+  async getSources(): Promise<CodeClimbers.Source[]> {
+    const userAgentsAndLastActive =
+      await this.pulseRepo.getUniqueUserAgentsAndLastActive()
+    const sources = new Set<string>()
+
+    userAgentsAndLastActive.forEach((userAgent) => {
+      const source = activitiesUtil.getSourceFromUserAgent(userAgent.userAgent)
+      if (source) {
+        sources.add(source)
+      }
+    })
+
+    return Array.from(sources).map((source) => {
+      const maxLastActive = userAgentsAndLastActive
+        .filter((userAgent) => {
+          return (
+            source ===
+            activitiesUtil.getSourceFromUserAgent(userAgent.userAgent)
+          )
+        })
+        .reduce((max, userAgent) => {
+          return new Date(userAgent.lastActive) > new Date(max)
+            ? userAgent.lastActive
+            : max
+        }, new Date(0).toISOString())
+
+      return { name: source, lastActive: maxLastActive }
+    })
+  }
+
+  async generatePulsesCSV(): Promise<Buffer> {
+    const pulses = await this.pulseRepo.getAllPulses()
+    const csvString = this.convertPulsesToCSV(pulses)
+    return Buffer.from(csvString, 'utf-8')
+  }
+
+  private userAgent() {
+    const platform = os.platform()
+    const release = os.release()
+    const arch = os.arch()
+    const nodeVersion = process.version
+
+    return `Node/${nodeVersion.slice(1)} (${platform}; ${arch}) OS/${release}`
+  }
+
+  private mapDtoToPulse(
+    dto: CreateWakatimePulseDto,
+    latestProject?: string,
+  ): CodeClimbers.Pulse {
+    const project =
+      (dto.project === '<<PROJECT>>' || !dto.project) && latestProject
+        ? latestProject
+        : dto.project
+
+    return {
+      userId: 'local',
+      project,
+      branch: dto.branch,
+      entity: dto.entity,
+      type: dto.type,
+      isWrite: dto.is_write || false,
+      editor: dto.editor || '',
+      language: dto.language || Intl.DateTimeFormat().resolvedOptions().locale,
+      operatingSystem: dto.operating_system || os.platform(),
+      machine: dto.machine || os.hostname(),
+      userAgent: dto.user_agent || this.userAgent(),
+      time: dayjs((dto.time as number) * 1000).toISOString(),
+      hash: `${activitiesUtil.calculatePulseHash(dto)}`,
+      origin: dto.origin || '',
+      originId: dto.origin_id || '',
+      category: dto.category || '',
+      createdAt: dayjs().toISOString(),
+    }
+  }
+
+  private convertPulsesToCSV(pulses: CodeClimbers.Pulse[]): string {
+    const header = [
+      'ID',
+      'User ID',
+      'Entity',
+      'Type',
+      'Category',
+      'Project',
+      'Branch',
+      'Language',
+      'Is Write',
+      'Editor',
+      'Operating System',
+      'Machine',
+      'User Agent',
+      'Time',
+      'Hash',
+      'Origin',
+      'Origin ID',
+      'Created At',
+      'Description',
+    ].join(',')
+
+    const rows = pulses.map((row) =>
+      [
+        row.id,
+        row.userId,
+        row.entity,
+        row.type,
+        row.category,
+        row.project,
+        row.branch,
+        row.language,
+        row.isWrite,
+        row.editor,
+        row.operatingSystem,
+        row.machine,
+        row.userAgent,
+        row.time,
+        row.hash,
+        row.origin,
+        row.originId,
+        row.createdAt,
+        row.description,
+      ]
+        .map((value) => (value === null ? '' : value.toString()))
+        .join(','),
+    )
+
+    return [header, ...rows].join('\n')
+  }
+}

package/src/v1/activities/pulse.controller.ts

@@ -0,0 +1,68 @@
+import { Controller, Get, Query, Res } from '@nestjs/common'
+import { ActivitiesService } from './activities.service'
+import { Response } from 'express'
+import { GetCategoryTimeOverviewDto } from '../dtos/getCategoryTimeOverview.dto'
+import { GetWeekOverviewDto } from '../dtos/getWeekOverview.dto'
+
+@Controller('pulses')
+export class PulseController {
+  constructor(private readonly activitiesService: ActivitiesService) {
+    this.activitiesService = activitiesService
+  }
+  @Get('latest')
+  async latestPulses(): Promise<{
+    message: string
+    data: CodeClimbers.Pulse[] | undefined
+  }> {
+    const pulse = await this.activitiesService.getLatestPulses()
+    return { message: 'success', data: pulse }
+  }
+
+  @Get('weekOverview')
+  async getWeekOverview(
+    @Query() dto: GetWeekOverviewDto,
+  ): Promise<CodeClimbers.WeekOverviewDao> {
+    const result: CodeClimbers.WeekOverview =
+      await this.activitiesService.getWeekOverview(dto.date)
+    return { message: 'success', data: result }
+  }
+
+  @Get('categoryTimeOverview')
+  async getCategoryTimeOverview(
+    @Query() times: GetCategoryTimeOverviewDto,
+  ): Promise<CodeClimbers.TimeOverviewDao> {
+    const result: CodeClimbers.TimeOverview[] =
+      await this.activitiesService.getCategoryTimeOverview(
+        times.startDate,
+        times.endDate,
+      )
+    return { message: 'success', data: result }
+  }
+
+  @Get('sources')
+  async getSources(): Promise<
+    Promise<{
+      message: string
+      data: CodeClimbers.Source[] | []
+    }>
+  > {
+    const sources = await this.activitiesService.getSources()
+    return { message: 'success', data: sources }
+  }
+
+  @Get('export')
+  async exportPulses(@Res() response: Response): Promise<void> {
+    try {
+      const csvBuffer = await this.activitiesService.generatePulsesCSV()
+      response.setHeader('Content-Type', 'text/csv')
+      response.setHeader(
+        'Content-Disposition',
+        'attachment; filename="pulses.csv"',
+      )
+      response.send(csvBuffer)
+    } catch (error) {
+      console.error('Error exporting pulses CSV:', error)
+      response.status(500).send('Failed to export pulses')
+    }
+  }
+}

package/src/v1/activities/wakatimeProxy.controller.ts

@@ -0,0 +1,33 @@
+import { Body, Controller, Get, Logger, Post } from '@nestjs/common'
+import { ActivitiesService } from './activities.service'
+import { CreateWakatimePulseDto } from '../dtos/createWakatimePulse.dto'
+
+@Controller('wakatime')
+export class WakatimeController {
+  constructor(private readonly activitiesService: ActivitiesService) {
+    this.activitiesService = activitiesService
+  }
+  @Get('users/current/statusbar/today')
+  async getStatusBar(): Promise<CodeClimbers.ActivitiesStatusBar> {
+    const result = await this.activitiesService.getActivityStatusBar()
+    return result
+  }
+
+  @Post('users/current/heartbeats')
+  async createPulse(@Body() body: CreateWakatimePulseDto): Promise<{
+    Responses: number[][]
+  }> {
+    Logger.log(JSON.stringify(body), 'wakatimeProxy.controller')
+    const result = await this.activitiesService.createPulse(body)
+    return result
+  }
+
+  @Post('users/current/heartbeats.bulk')
+  async createPulses(@Body() body: CreateWakatimePulseDto[]): Promise<{
+    Responses: number[][]
+  }> {
+    Logger.log(JSON.stringify(body), 'wakatimeProxy.controller')
+    const result = await this.activitiesService.createPulses(body)
+    return result
+  }
+}

package/src/v1/database/__tests__/knex.test.ts

@@ -0,0 +1,18 @@
+import { knex, SQL_LITE_TEST_FILE } from '../knex'
+
+describe('knex', () => {
+  it('Should connect successfully', async () => {
+    await knex.raw('SELECT 1').catch((e) => {
+      expect(e).toBeUndefined()
+    })
+  })
+
+  it('Should be using test path', () => {
+    expect(knex.client.config.connection.filename).toEqual(SQL_LITE_TEST_FILE)
+  })
+})
+
+afterAll((done) => {
+  knex.destroy()
+  done()
+})

package/src/v1/database/__tests__/pulse.repo.test.ts

@@ -0,0 +1,209 @@
+import { knex } from '../knex'
+import { PulseRepo } from '../pulse.repo'
+
+const pulseRepo = new PulseRepo(knex)
+
+describe('pulse.repo', () => {
+  const SECOND = 1_000
+  const MINUTE = SECOND * 60
+  const HOUR = MINUTE * 60
+  const DAY = HOUR * 24
+  const YEAR = DAY * 365
+  const NOW = new Date()
+  NOW.setUTCHours(0, 0, 0, 0)
+
+  const TIMESTAMP = NOW.getTime()
+
+  // SEED BASED TESTS:
+  it('Should get latest pulses', async () => {
+    const pulses = await pulseRepo.getLatestPulses()
+    expect(pulses.length).toEqual(10)
+    // Make sure it is the newest ones
+    pulses.slice(0, 3).forEach((pulse) => {
+      expect(pulse.entity).toEqual('NEW')
+    })
+  })
+
+  it('Should get all pulses', async () => {
+    const pulses = await pulseRepo.getAllPulses()
+    expect(pulses.length).toEqual(102)
+  })
+
+  it('Should get minutes in range', async () => {
+    const endDate = new Date()
+    const startDate = new Date(endDate.getTime() - HOUR * 2)
+    const minutes = await pulseRepo.getRangeMinutes(startDate, endDate)
+
+    expect(minutes).toEqual(2)
+  })
+
+  it('Should get the longest day in minutes range', async () => {
+    const TEN_DAYS = DAY * 10
+
+    const endDate = new Date()
+    endDate.setUTCHours(0, 0, 0, 0)
+    const startDate = new Date(endDate.getTime() - TEN_DAYS)
+    startDate.setUTCHours(0, 0, 0, 0)
+
+    const longestDay = await pulseRepo.getLongestDayInRangeMinutes(
+      startDate,
+      endDate,
+    )
+
+    expect(longestDay).toEqual(2)
+  })
+
+  it('Should get category time overview', async () => {
+    const TEN_DAYS = DAY * 10
+
+    const endDate = new Date()
+    const startDate = new Date(endDate.getTime() - TEN_DAYS)
+
+    const categoryTimeOverview = await pulseRepo.getCategoryTimeOverview(
+      startDate.toISOString(),
+      endDate.toISOString(),
+    )
+
+    expect(categoryTimeOverview.length).toEqual(2)
+  })
+
+  it('Should get the last project', async () => {
+    const lastProject = await pulseRepo.getLatestProject()
+    expect(lastProject).toEqual('Latest Project')
+  })
+
+  it('Should get unique user agents and last active', async () => {
+    const uniqueUserAgents = await pulseRepo.getUniqueUserAgentsAndLastActive()
+    expect(uniqueUserAgents.length).toEqual(3)
+
+    const vscode = uniqueUserAgents.find((n) => n.userAgent === 'vscode')
+    const VSCODE_LAST_ACTIVE = new Date(TIMESTAMP - DAY)
+    expect(vscode).toBeTruthy()
+    expect(vscode.lastActive).toEqual(VSCODE_LAST_ACTIVE.toISOString())
+
+    const chrome = uniqueUserAgents.find(
+      (n) => n.userAgent === 'chrome-chrome_extension',
+    )
+    const CHROME_LAST_ACTIVE = new Date(TIMESTAMP - DAY * 3)
+    expect(chrome).toBeTruthy()
+    expect(chrome.lastActive).toEqual(CHROME_LAST_ACTIVE.toISOString())
+  })
+
+  // --------- WRITES ------------
+  const dummyPulse = (time?: string): CodeClimbers.Pulse => ({
+    userId: '1',
+    entity: 'NEW',
+    category: 'NEW',
+    time: time ?? new Date().toISOString(),
+    createdAt: time ?? new Date().toISOString(),
+    project: 'NEW',
+    type: '',
+    isWrite: false,
+    editor: '',
+    operatingSystem: '',
+    machine: '',
+    userAgent: '',
+    hash: String(Math.floor(new Date().getTime() / Math.random())),
+  })
+
+  it('Should create a pulse', async () => {
+    const createdPulse = await pulseRepo.createPulse(dummyPulse())
+
+    expect(createdPulse).toBeTruthy()
+    expect(createdPulse).toHaveLength(1)
+  })
+
+  it('Should create pulses', async () => {
+    const createdPulses = await pulseRepo.createPulses([
+      dummyPulse(),
+      dummyPulse(),
+    ])
+
+    expect(createdPulses).toBeTruthy()
+    expect(createdPulses).toHaveLength(2)
+  })
+
+  // LOGIC BASED TESTS. Go back a year to prevent issues with seeder data.
+  it('Should group many heartbeats within a 2 minute period correctly', async () => {
+    const interval = SECOND * 10
+    const timePeriod = 12
+
+    const startDate = new Date(TIMESTAMP - YEAR)
+    const endDate = new Date(TIMESTAMP - YEAR + interval * timePeriod)
+
+    const pulses = []
+    for (let i = 0; i < timePeriod; i++) {
+      pulses.push(
+        dummyPulse(new Date(startDate.getTime() + i * interval).toISOString()),
+      )
+    }
+
+    await pulseRepo.createPulses(pulses)
+
+    const minutes = await pulseRepo.getRangeMinutes(startDate, endDate)
+    expect(minutes).toEqual(2)
+  })
+
+  it('Should group many heart beats at a different intervals correctly', async () => {
+    const timeAgo = TIMESTAMP - YEAR - DAY * 2
+
+    const startDate = new Date(timeAgo)
+    const endDate = new Date(timeAgo + MINUTE * 45)
+
+    // Start, 3 at 10 minutes, 2 at 20 minutes, 30 minutes.
+    // 7 total, but should only count as 4.
+    await pulseRepo.createPulses([
+      dummyPulse(new Date(startDate.getTime()).toISOString()),
+      dummyPulse(new Date(startDate.getTime() + MINUTE * 10).toISOString()),
+      dummyPulse(
+        new Date(startDate.getTime() + MINUTE * 10 + SECOND * 9).toISOString(),
+      ),
+      dummyPulse(
+        new Date(startDate.getTime() + MINUTE * 10 + SECOND * 5).toISOString(),
+      ),
+      dummyPulse(new Date(startDate.getTime() + MINUTE * 20).toISOString()),
+      dummyPulse(
+        new Date(startDate.getTime() + MINUTE * 20 + SECOND * 5).toISOString(),
+      ),
+      dummyPulse(new Date(startDate.getTime() + MINUTE * 30).toISOString()),
+    ])
+
+    const minutes = await pulseRepo.getRangeMinutes(startDate, endDate)
+    expect(minutes).toEqual(8)
+  })
+
+  // Edge case: Does the query handle days. If I have a heartbeat at 11:59pm or 12:00am, does that heartbeat count towards the correct day?
+  it('Should group heartbeats at the end of the day correctly', async () => {
+    const timeAgo = TIMESTAMP - YEAR - DAY * 14
+
+    const startDate = new Date(timeAgo)
+    const endDate = new Date(timeAgo + DAY * 7)
+
+    // Start, 11:59pm, 12:00am, 12:01am.
+    // 5 total, but should only count as 2
+    await pulseRepo.createPulses([
+      dummyPulse(new Date(startDate.getTime()).toISOString()),
+      dummyPulse(new Date(startDate.getTime() - MINUTE).toISOString()),
+      dummyPulse(new Date(startDate.getTime() + DAY - MINUTE).toISOString()),
+      dummyPulse(new Date(startDate.getTime() + DAY).toISOString()),
+      dummyPulse(new Date(startDate.getTime() + DAY + MINUTE).toISOString()),
+      dummyPulse(
+        new Date(startDate.getTime() + DAY + MINUTE * 2).toISOString(),
+      ),
+    ])
+
+    const minutes = await pulseRepo.getLongestDayInRangeMinutes(
+      startDate,
+      endDate,
+    )
+
+    expect(minutes).toEqual(3)
+  })
+
+  // TODO: Write test for representing categories correctly, as they are not all equal.
+})
+
+afterAll((done) => {
+  knex.destroy()
+  done()
+})