@codeclimbers/server 0.0.1

package/src/v1/startup/startupService.factory.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common'
+import { DarwinStartupService } from './darwinStartup.service'
+import { UnsupportedStartupService } from './unsupportedStartup.service'
+
+@Injectable()
+export class StartupServiceFactory {
+  constructor(
+    private readonly darwinStartupService: DarwinStartupService,
+    private readonly unsupportedStartupService: UnsupportedStartupService,
+  ) {}
+
+  getStartupService(): CodeClimbers.StartupService {
+    const os = process.platform
+    switch (os) {
+      case 'darwin':
+        return this.darwinStartupService
+      default:
+        return this.unsupportedStartupService
+    }
+  }
+
+  static buildStartupService(): CodeClimbers.StartupService {
+    return new StartupServiceFactory(
+      new DarwinStartupService(),
+      new UnsupportedStartupService(),
+    ).getStartupService()
+  }
+}

package/src/v1/startup/unsupportedStartup.service.ts

@@ -0,0 +1,21 @@
+import { Injectable, Logger } from '@nestjs/common'
+
+@Injectable()
+export class UnsupportedStartupService implements CodeClimbers.StartupService {
+  async enableStartup() {
+    Logger.error(`Unsupported operating system: ${process.platform}`)
+  }
+
+  async disableStartup() {
+    Logger.error(`Unsupported operating system: ${process.platform}`)
+  }
+
+  // cleanly separate implementation code for each environment. If I'm working on windows, I see all the implementation around startup
+  async launchAndEnableStartup() {
+    Logger.error(`Unsupported operating system: ${process.platform}`)
+  }
+
+  async closeAndDisableStartup() {
+    Logger.error(`Unsupported operating system: ${process.platform}`)
+  }
+}

package/src/v1/v1.module.ts

@@ -0,0 +1,28 @@
+import { Module } from '@nestjs/common'
+import { HealthController } from '../common/infrastructure/http/controllers/health.controller'
+import { StartupController } from './startup/startup.controller'
+import { ActivitiesService } from './activities/activities.service'
+import { PulseController } from './activities/pulse.controller'
+import { WakatimeController } from './activities/wakatimeProxy.controller'
+import { PulseRepo } from './database/pulse.repo'
+import { DarwinStartupService } from './startup/darwinStartup.service'
+import { StartupServiceFactory } from './startup/startupService.factory'
+import { UnsupportedStartupService } from './startup/unsupportedStartup.service'
+
+@Module({
+  imports: [],
+  controllers: [
+    HealthController,
+    PulseController,
+    WakatimeController,
+    StartupController,
+  ],
+  providers: [
+    ActivitiesService,
+    StartupServiceFactory,
+    PulseRepo,
+    UnsupportedStartupService,
+    DarwinStartupService,
+  ],
+})
+export class V1Module {}

package/test/app.e2e-spec.ts

@@ -0,0 +1,24 @@
+import { Test, TestingModule } from '@nestjs/testing'
+import { INestApplication } from '@nestjs/common'
+import * as request from 'supertest'
+import { AppModule } from './../src/app.module'
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile()
+
+    app = moduleFixture.createNestApplication()
+    await app.init()
+  })
+
+  it('/ (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/')
+      .expect(200)
+      .expect('Hello World!')
+  })
+})

package/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/test/jest.globalSetup.js

@@ -0,0 +1,15 @@
+const { knex, SQL_LITE_TEST_FILE } = require('../src/v1/database/knex')
+
+module.exports = async () => {
+  if (knex.client.config.connection.filename !== SQL_LITE_TEST_FILE) {
+    throw new Error('You are not using the test file')
+  }
+
+  console.log('\n======== SETUP - DROP ========')
+  await knex.migrate.rollback({}, true)
+
+  console.log('======== SETUP - MIGRATION ========')
+  await knex.migrate.latest()
+  console.log('======== SETUP - SEED ========')
+  await knex.seed.run()
+}

package/test/jest.globalTeardown.js

@@ -0,0 +1,8 @@
+const { knex } = require('../src/v1/database/knex')
+
+module.exports = async () => {
+  // Don't disconnect the DB if in watch mode
+  if (process.env.JEST_WATCH) return
+
+  await knex.destroy()
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "jsx": "react-jsx",
+    "module": "CommonJS",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+  },
+}

package/utils/__tests__/activites.util.test.ts

@@ -0,0 +1,18 @@
+import activitiesUtil from '../activities.util'
+
+describe('getSourceFromUserAgent', () => {
+  it(`should return 'vscode' as source of userAgents`, () => {
+    const userAgents = [
+      'wakatime/v1.98.1 (windows-10.0.22631.3880-unknown) go1.22.5 vscode/1.91.1 vscode-climbers/0.0.0',
+      'wakatime/v1.98.1 (windows-10.0.22631.3880-unknown) go1.22.5 vscode/1.91.1 vscode-wakatime/24.6.0',
+      'wakatime/v1.98.3 (windows-10.0.22631.3880-unknown) go1.22.5 vscode/1.91.1 vscode-climbers/0.0.0',
+      'wakatime/v1.98.3 (windows-10.0.22631.3880-unknown) go1.22.5 vscode/1.91.1 vscode-wakatime/24.6.0',
+    ]
+
+    const result = userAgents.map((userAgent) => {
+      return activitiesUtil.getSourceFromUserAgent(userAgent)
+    })
+
+    expect(result).toEqual(['vscode', 'vscode', 'vscode', 'vscode'])
+  })
+})

package/utils/__tests__/helpers.util.test.ts

@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+  forOwn,
+  isPlainObject,
+  snakeCase,
+  camelCase,
+  maxBy,
+  minBy,
+  groupBy,
+} from '../helpers.util'
+
+describe('forOwn', () => {
+  it('should iterate over own enumerable properties', () => {
+    const obj = { a: 1, b: 2, c: 3 }
+    const result: [string, number][] = []
+
+    forOwn(obj, (value, key) => {
+      result.push([key, value])
+    })
+
+    expect(result).toEqual([
+      ['a', 1],
+      ['b', 2],
+      ['c', 3],
+    ])
+  })
+
+  it('should handle empty objects', () => {
+    const obj = {}
+    let count = 0
+
+    forOwn(obj, () => {
+      count++
+    })
+
+    expect(count).toBe(0)
+  })
+})
+
+describe('isPlainObject', () => {
+  it('should return true for plain objects', () => {
+    expect(isPlainObject({})).toBe(true)
+    expect(isPlainObject({ a: 1 })).toBe(true)
+    expect(isPlainObject(Object.create(null))).toBe(true)
+  })
+
+  it('should return false for non-plain objects', () => {
+    expect(isPlainObject(null)).toBe(false)
+    expect(isPlainObject(undefined)).toBe(false)
+    expect(isPlainObject(123)).toBe(false)
+    expect(isPlainObject('string')).toBe(false)
+    expect(isPlainObject([])).toBe(false)
+    expect(isPlainObject(new Date())).toBe(false)
+  })
+})
+
+describe('snakeCase', () => {
+  it('should convert strings to snake case', () => {
+    expect(snakeCase('hello world')).toBe('hello_world')
+    expect(snakeCase('helloWorld')).toBe('hello_world')
+    expect(snakeCase('HelloWorld')).toBe('hello_world')
+    expect(snakeCase('hello-world')).toBe('hello_world')
+  })
+
+  it('should handle non-string inputs', () => {
+    expect(snakeCase(null as any)).toBe('')
+    expect(snakeCase(123 as any)).toBe('')
+  })
+})
+
+describe('camelCase', () => {
+  it('should convert strings to camel case', () => {
+    expect(camelCase('hello world')).toBe('helloWorld')
+    expect(camelCase('hello-world')).toBe('helloWorld')
+    expect(camelCase('hello_world')).toBe('helloWorld')
+    expect(camelCase('Hello World')).toBe('helloWorld')
+    expect(camelCase('HELLO WORLD')).toBe('helloWorld')
+  })
+
+  it('should handle non-string inputs', () => {
+    expect(camelCase(null as any)).toBe('')
+    expect(camelCase(123 as any)).toBe('')
+  })
+})
+
+describe('maxBy', () => {
+  it('should return the maximum value by the given key', () => {
+    const arr = [
+      { a: 1, b: 3 },
+      { a: 2, b: 1 },
+      { a: 3, b: 2 },
+    ]
+
+    // row 3
+    // row 1Î
+    expect(maxBy(arr, (x) => x.a)).toEqual({ a: 3, b: 2 })
+    expect(maxBy(arr, (x) => x.b)).toEqual({ a: 1, b: 3 })
+  })
+
+  it('should return undefined for empty arrays', () => {
+    expect(
+      maxBy([], () => {
+        return
+      }),
+    ).toBeUndefined()
+  })
+})
+
+describe('minBy', () => {
+  it('should return the minimum value by the given key', () => {
+    const arr = [
+      { a: 1, b: 2 },
+      { a: 2, b: 1 },
+      { a: 3, b: 3 },
+    ]
+
+    expect(minBy(arr, (x) => x.a)).toEqual({ a: 1, b: 2 })
+    expect(minBy(arr, (x) => x.b)).toEqual({ a: 2, b: 1 })
+  })
+
+  it('should return undefined for empty arrays', () => {
+    expect(
+      minBy([], () => {
+        return
+      }),
+    ).toBeUndefined()
+  })
+})
+
+describe('groupBy', () => {
+  it('should group items by the given key', () => {
+    const arr = [
+      { a: 1, b: 2 },
+      { a: 2, b: 1 },
+      { a: 1, b: 3 },
+    ]
+
+    const result = groupBy(arr, 'a' as any)
+
+    expect(result).toEqual({
+      1: [
+        { a: 1, b: 2 },
+        { a: 1, b: 3 },
+      ],
+      2: [{ a: 2, b: 1 }],
+    })
+  })
+
+  it('should handle empty arrays', () => {
+    const arr: any[] = []
+    const result = groupBy(arr, 'a' as any)
+
+    expect(result).toEqual({})
+  })
+})

package/utils/__tests__/wakatime.util.test.ts

@@ -0,0 +1,222 @@
+import { IniConfig, parseIni, stringifyIni } from '../wakatime.util'
+
+describe('parseIni', () => {
+  it('should parse a valid INI string with one section', () => {
+    const input = `
+      [section1]
+      key1 = value1
+      key2 = value2
+    `
+    const expected: IniConfig = {
+      section1: {
+        key1: 'value1',
+        key2: 'value2',
+      },
+    }
+    expect(parseIni(input)).toEqual(expected)
+  })
+
+  it('should parse a valid INI string with multiple sections', () => {
+    const input = `
+      [section1]
+      key1 = value1
+      key2 = value2
+
+      [section2]
+      key3 = value3
+      key4 = value4
+    `
+    const expected: IniConfig = {
+      section1: {
+        key1: 'value1',
+        key2: 'value2',
+      },
+      section2: {
+        key3: 'value3',
+        key4: 'value4',
+      },
+    }
+    expect(parseIni(input)).toEqual(expected)
+  })
+
+  it('should handle empty input', () => {
+    const input = ''
+    const expected: IniConfig = {}
+    expect(parseIni(input)).toEqual(expected)
+  })
+
+  it('should handle input with only whitespace', () => {
+    const input = '   \n  \t  '
+    const expected: IniConfig = {}
+    expect(parseIni(input)).toEqual(expected)
+  })
+
+  it('should ignore lines without a section', () => {
+    const input = `
+      key1 = value1
+      [section1]
+      key2 = value2
+    `
+    const expected: IniConfig = {
+      section1: {
+        key2: 'value2',
+      },
+    }
+    expect(parseIni(input)).toEqual(expected)
+  })
+
+  it('should handle malformed lines within a section', () => {
+    const input = `
+      [section1]
+      key1 = value1
+      malformed line
+      key2 = value2
+    `
+    const expected: IniConfig = {
+      section1: {
+        key1: 'value1',
+        key2: 'value2',
+      },
+    }
+    expect(parseIni(input)).toEqual(expected)
+  })
+
+  it('should handle keys without values', () => {
+    const input = `
+      [section1]
+      key1 = value1
+      key2 =
+      key3 = value3
+    `
+    const expected: IniConfig = {
+      section1: {
+        key1: 'value1',
+        key3: 'value3',
+      },
+    }
+    expect(parseIni(input)).toEqual(expected)
+  })
+
+  it('should handle section names with spaces', () => {
+    const input = `
+      [Section One]
+      key1 = value1
+      [Section Two]
+      key2 = value2
+    `
+    const expected: IniConfig = {
+      'Section One': {
+        key1: 'value1',
+      },
+      'Section Two': {
+        key2: 'value2',
+      },
+    }
+    expect(parseIni(input)).toEqual(expected)
+  })
+})
+
+describe('stringifyIni', () => {
+  it('should return an empty string for empty input', () => {
+    const input: IniConfig = {}
+    const expected = '\n'
+    expect(stringifyIni(input)).toBe(expected)
+  })
+
+  it('should correctly stringify a single section with multiple entries', () => {
+    const input: IniConfig = {
+      section1: {
+        key1: 'value1',
+        key2: 'value2',
+        key3: 'value3',
+      },
+    }
+    const expected = `[section1]
+key1 = value1
+key2 = value2
+key3 = value3\n`
+    expect(stringifyIni(input)).toBe(expected)
+  })
+
+  it('should correctly stringify multiple sections with multiple entries', () => {
+    const input: IniConfig = {
+      section1: {
+        key1: 'value1',
+        key2: 'value2',
+      },
+      section2: {
+        key3: 'value3',
+        key4: 'value4',
+      },
+    }
+    const expected = `[section1]
+key1 = value1
+key2 = value2
+
+[section2]
+key3 = value3
+key4 = value4\n`
+    expect(stringifyIni(input)).toBe(expected)
+  })
+
+  it('should handle sections with no entries', () => {
+    const input: IniConfig = {
+      section1: {},
+      section2: {
+        key1: 'value1',
+      },
+      section3: {},
+    }
+    const expected = `[section1]
+
+
+[section2]
+key1 = value1
+
+[section3]
+\n`
+    expect(stringifyIni(input)).toBe(expected)
+  })
+
+  it('should handle a mix of sections with and without entries', () => {
+    const input: IniConfig = {
+      section1: {
+        key1: 'value1',
+      },
+      section2: {},
+      section3: {
+        key2: 'value2',
+        key3: 'value3',
+      },
+      section4: {},
+    }
+
+    const expected = `[section1]
+key1 = value1
+
+[section2]
+
+
+[section3]
+key2 = value2
+key3 = value3
+
+[section4]
+\n`
+    console.log(stringifyIni(input))
+    expect(stringifyIni(input)).toBe(expected)
+  })
+
+  it('should handle values containing spaces', () => {
+    const input: IniConfig = {
+      section1: {
+        key1: 'value with spaces',
+        key2: 'another value with spaces',
+      },
+    }
+    const expected = `[section1]
+key1 = value with spaces
+key2 = another value with spaces\n`
+    expect(stringifyIni(input)).toBe(expected)
+  })
+})