@codeclimbers/server 0.0.1

package/utils/activities.util.ts

@@ -0,0 +1,193 @@
+import * as dayjs from 'dayjs'
+import { groupBy, maxBy, minBy } from './helpers.util'
+const cyrb53 = (str: string, seed = 0) => {
+  let h1 = 0xdeadbeef ^ seed,
+    h2 = 0x41c6ce57 ^ seed
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i)
+    h1 = Math.imul(h1 ^ ch, 2654435761)
+    h2 = Math.imul(h2 ^ ch, 1597334677)
+  }
+  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507)
+  h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909)
+  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507)
+  h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909)
+
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0)
+}
+
+const calculatePulseHash = (
+  pulse: CodeClimbers.CreateWakatimePulseDto,
+): number => {
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  const {
+    editor, // do not include these fields in hash
+    user_agent,
+    origin,
+    origin_id,
+    operating_system,
+    machine,
+    ...pulseHash
+  } = { ...pulse }
+
+  const hash = cyrb53(JSON.stringify(pulseHash))
+  return hash
+}
+
+function filterUniqueByHash(arr: CodeClimbers.Pulse[]) {
+  const uniqueMap = new Map()
+
+  return arr.filter((obj) => {
+    if (!uniqueMap.has(obj.hash)) {
+      uniqueMap.set(obj.hash, true)
+      return true
+    }
+    return false
+  })
+}
+
+function pulseSuccessResponse(n: number) {
+  const responses = [...Array(n).keys()].map((i) => [null, 201])
+
+  return {
+    Responses: responses,
+  }
+}
+
+function defaultStatusBar(): CodeClimbers.ActivitiesStatusBar {
+  const now = dayjs()
+
+  return {
+    data: {
+      categories: [],
+      dependencies: [],
+      editors: [],
+      languages: [],
+      machines: [],
+      operating_systems: [],
+      projects: [],
+      branches: null,
+      entities: null,
+      grand_total: {
+        digital: '0:0',
+        hours: 0,
+        minutes: 0,
+        text: '0 hrs 0 mins',
+        total_seconds: 0,
+      },
+      range: {
+        date: now.toISOString(),
+        end: now.toISOString(),
+        start: now.startOf('day').toISOString(),
+        text: '',
+        timezone: 'UTC',
+      },
+    },
+    cached_at: now.toISOString(),
+  }
+}
+function getStatusByKey(
+  data: CodeClimbers.WakatimePulseStatusDao[],
+  dataKey: string,
+): CodeClimbers.ActivitiesDetail[] {
+  const keyWithoutS = dataKey.replace(/s$/, '')
+  const groupedData = groupBy(data, keyWithoutS)
+  return Object.keys(groupedData).map((key: string) => {
+    const group = groupedData[key]
+    const totalSeconds = group.reduce(
+      (acc, x) => acc + parseInt(x.seconds as string),
+      0,
+    )
+    const hours = Math.floor(totalSeconds / 3600)
+    const minutes = Math.floor((totalSeconds % 3600) / 60)
+    const seconds = Math.floor(totalSeconds % 60)
+    return {
+      digital: `${hours}:${minutes}:${seconds}`,
+      hours,
+      minutes,
+      name: key || 'unknown',
+      percent: 100,
+      seconds,
+      text: `${hours} hrs ${seconds >= 30 ? minutes + 1 : minutes} mins`,
+      total_seconds: data.reduce(
+        (acc, x) => acc + parseInt(x.seconds as string),
+        0,
+      ),
+    }
+  })
+}
+
+function mapStatusBarRawToDto(
+  statusBarRaw: CodeClimbers.WakatimePulseStatusDao[],
+): CodeClimbers.ActivitiesStatusBar {
+  if (statusBarRaw.length <= 0) return defaultStatusBar()
+  const now = new Date()
+
+  const statusbar: CodeClimbers.ActivitiesStatusBar = {
+    cached_at: '',
+    data: {
+      branches: null,
+      entities: null,
+    },
+  }
+
+  statusbar.data.editors = getStatusByKey(statusBarRaw, 'editors')
+  statusbar.data.languages = getStatusByKey(statusBarRaw, 'languages')
+  statusbar.data.machines = getStatusByKey(statusBarRaw, 'machines')
+  statusbar.data.operating_systems = getStatusByKey(
+    statusBarRaw,
+    'operating_systems',
+  )
+  statusbar.data.projects = getStatusByKey(statusBarRaw, 'projects')
+
+  // const grandTotalSeconds = sumBy(statusBarRaw, (x) => parseInt(x.seconds))
+  const grandTotalSeconds = statusBarRaw.reduce(
+    (acc, x) => acc + parseInt(x.seconds as string),
+    0,
+  )
+  const hours = Math.floor(grandTotalSeconds / 3600)
+  const minutes = Math.floor((grandTotalSeconds % 3600) / 60)
+  const seconds = Math.floor(grandTotalSeconds % 60)
+  statusbar.data.grand_total = {
+    digital: `${hours}:${minutes}`,
+    hours,
+    minutes,
+    text: `${hours} hrs ${seconds >= 30 ? minutes + 1 : minutes} mins`,
+    total_seconds: grandTotalSeconds,
+  }
+
+  const dates = statusBarRaw.map((x) => new Date(x.maxHeartbeatTime))
+  statusbar.data.range = {
+    date: new Date().toISOString(),
+    end:
+      maxBy(statusBarRaw, (item) => new Date(item.maxHeartbeatTime))
+        ?.maxHeartbeatTime || '',
+    start:
+      minBy(statusBarRaw, (item) => new Date(item.minHeartbeatTime))
+        ?.minHeartbeatTime || '',
+    text: '',
+    timezone: 'UTC',
+  }
+  statusbar.cached_at = new Date().toISOString()
+
+  return statusbar
+}
+
+function getSourceFromUserAgent(userAgent: string): string | undefined {
+  const sourceRegex = /.*?\/.*?\s([^0-9]*)\//
+  const match = userAgent.match(sourceRegex)
+  if (match) {
+    return match[1]
+  }
+
+  return undefined
+}
+
+export default {
+  mapStatusBarRawToDto,
+  calculatePulseHash,
+  filterUniqueByHash,
+  pulseSuccessResponse,
+  cyrb53,
+  getSourceFromUserAgent,
+}

package/utils/allExceptions.filter.ts

@@ -0,0 +1,43 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common'
+
+export type BEErrorReport = {
+  customMessage?: string
+} & Error
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  async catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp()
+    const response = ctx.getResponse()
+
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.INTERNAL_SERVER_ERROR
+    const message =
+      exception instanceof HttpException
+        ? exception.getResponse()
+        : 'Internal server error'
+
+    const errorReport: BEErrorReport = {
+      message: typeof message === 'object' ? JSON.stringify(message) : message,
+      name: exception instanceof Error ? exception.name : 'Error',
+      stack: exception instanceof Error ? exception.stack : undefined,
+    }
+    if (status >= 500) {
+      Logger.error(errorReport)
+      // Sentry.captureException(exception)
+    } else {
+      Logger.debug(errorReport)
+    }
+
+    response.status(status).json(message)
+  }
+}

package/utils/codeClimberErrors.ts

@@ -0,0 +1,32 @@
+import { ValidationError } from 'class-validator'
+
+/**
+ * Custom Errors are used when a developer wants the error to be displayed to the end user
+ * All other errors are reported internally
+ */
+export class CodeClimberError extends Error {
+  public message!: string
+  public status: number
+
+  public constructor(message: string, status = 500) {
+    super(message)
+    this.name = this.constructor.name
+    Error.captureStackTrace(this, this.constructor)
+    this.status = status
+  }
+}
+
+export namespace CodeClimberError {
+  class ValidationErr extends CodeClimberError {
+    validationErrors?: ValidationError[]
+    public constructor(message: string, validationErrors?: ValidationError[]) {
+      super(message, 422)
+      this.validationErrors = validationErrors
+    }
+  }
+  export class InvalidBody extends ValidationErr {
+    constructor(validationErrors: ValidationError[], message?: string) {
+      super(message || 'Expected request body was invalid', validationErrors)
+    }
+  }
+}

package/utils/constants.ts

@@ -0,0 +1 @@
+export const PROCESS_NAME = 'codeclimbers-server'

package/utils/environment.util.ts

@@ -0,0 +1 @@
+export const isCli = () => process.env.CODECLIMBERS_SERVER_APP_CONTEXT === 'cli'

package/utils/helpers.util.ts

@@ -0,0 +1,131 @@
+export function forOwn<T>(
+  obj: Record<string, T>,
+  iteratee: (value: T, key: string, obj: Record<string, T>) => void,
+): void {
+  if (obj === null || obj === undefined) {
+    return
+  }
+
+  const keys = Object.keys(obj)
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i]
+    iteratee(obj[key], key, obj)
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isPlainObject(value: any): boolean {
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+
+  const prototype = Object.getPrototypeOf(value)
+  if (prototype === null) {
+    return true
+  }
+
+  const constructor = prototype.constructor
+  if (typeof constructor !== 'function') {
+    return false
+  }
+
+  const constructorString = Function.prototype.toString.call(constructor)
+  return (
+    constructorString.indexOf('[native code]') !== -1 && constructor === Object
+  )
+}
+
+export function snakeCase(str: string): string {
+  if (typeof str !== 'string') {
+    return ''
+  }
+
+  const result: string[] = []
+  let currentWord = ''
+
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i]
+    const nextChar = str[i + 1]
+
+    if (char === ' ' || char === '-') {
+      if (currentWord) {
+        result.push(currentWord.toLowerCase())
+        currentWord = ''
+      }
+    } else if (char >= 'A' && char <= 'Z') {
+      if (currentWord && nextChar && !(nextChar >= 'A' && nextChar <= 'Z')) {
+        result.push(currentWord.toLowerCase())
+        currentWord = ''
+      }
+      currentWord += char.toLowerCase()
+    } else {
+      currentWord += char
+    }
+  }
+
+  if (currentWord) {
+    result.push(currentWord.toLowerCase())
+  }
+
+  return result.join('_')
+}
+
+export function camelCase(str: string): string {
+  if (typeof str !== 'string') {
+    return ''
+  }
+
+  const words = str.split(/[\s-_]+/)
+  const result: string[] = []
+
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i]
+    if (word.length === 0) {
+      continue
+    }
+
+    if (i === 0) {
+      result.push(word.toLowerCase())
+    } else {
+      result.push(word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    }
+  }
+
+  return result.join('')
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function maxBy<T>(arr: T[], iteratee: (item: T) => any): T | undefined {
+  if (!arr || arr.length === 0) return undefined
+  return arr.reduce((acc, item) => {
+    const value = iteratee(item)
+    if (value > iteratee(acc)) return item
+    return acc
+  }, arr[0])
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function minBy<T>(arr: T[], iteratee: (item: T) => any): T | undefined {
+  if (!arr || arr.length === 0) return undefined
+  return arr.reduce((acc, item) => {
+    const value = iteratee(item)
+    if (value < iteratee(acc)) return item
+    return acc
+  }, arr[0])
+}
+
+// groupBy function that takes an array and groups it by a key
+export function groupBy<T>(arr: T[], key: string): Record<string, T[]> {
+  return arr.reduce(
+    (acc, item) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const keyValue = (item as Record<string, any>)[key]
+      if (!acc[keyValue]) {
+        acc[keyValue] = []
+      }
+      acc[keyValue].push(item)
+      return acc
+    },
+    {} as Record<string, T[]>,
+  )
+}

package/utils/node.util.ts

@@ -0,0 +1,29 @@
+import * as path from 'node:path'
+import * as os from 'node:os'
+import * as fs from 'node:fs'
+import { execSync } from 'node:child_process'
+
+export const BIN_PATH = path.join(__dirname, '..', '..', '..', '..', 'bin')
+export const HOME_DIR = os.homedir()
+export const CODE_CLIMBER_META_DIR = `${HOME_DIR}/.codeclimbers`
+export const DB_PATH = path.join(CODE_CLIMBER_META_DIR, 'codeclimber.sqlite')
+export const APP_DIST_PATH = path.join(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  'app',
+  'dist',
+)
+export const NODE_PATH = function () {
+  const result = execSync('which node').toString().trim()
+  const dir = result.slice(0, -5) // result is /usr/local/bin/node, we need to remove node
+  return dir
+}
+
+export const initDBDir = () => {
+  if (!fs.existsSync(CODE_CLIMBER_META_DIR)) {
+    fs.mkdirSync(CODE_CLIMBER_META_DIR, { recursive: true })
+  }
+  fs.chmodSync(CODE_CLIMBER_META_DIR, '755')
+}

package/utils/sql.util.ts

@@ -0,0 +1,13 @@
+export const toSQL = (query) => {
+  const { sql, bindings } = query.toSQL()
+  const fullQuery = bindings.reduce(
+    (acc, binding) =>
+      acc.replace(
+        '?',
+        binding instanceof Date ? `'${binding.toISOString()}'` : `'${binding}'`,
+      ),
+    sql,
+  )
+  console.log(fullQuery)
+  return fullQuery
+}

package/utils/sqlReader.util.ts

@@ -0,0 +1,49 @@
+import { readFile } from 'fs/promises'
+import { dirname, join } from 'path'
+
+// Initialize a cache object
+const cache: Record<string, string> = {}
+
+// Utility function to read file content and return it as a string
+async function getFileContentAsString(
+  fileName: string,
+  additionalPath = 'queries',
+) {
+  try {
+    // Dynamically determine the directory of the caller
+    // Create a new Error and use its stack trace
+    const err = new Error()
+    const stack = err.stack || ''
+    // Find the second entry in the stack trace, which should correspond to the caller
+    const caller = stack.split('\n')[2] || ''
+    // Extract the file path from the caller string
+    const match = caller.match(/\((?:file:\/\/)?(.*?):\d+:\d+\)$/)
+    if (!match) {
+      throw new Error('Could not determine caller file path')
+    }
+    const callerPath = match[1]
+    const callerDir = dirname(callerPath)
+
+    // Generate a unique cache key based on the caller directory and file name
+    const cacheKey = `${callerDir}:${additionalPath}:${fileName}`
+
+    // Check if the result is already in the cache
+    if (cache[cacheKey]) {
+      return cache[cacheKey] // Return the cached result
+    }
+
+    // Resolve the file path relative to the caller file's directory
+    const resolvedPath = join(callerDir, additionalPath, fileName)
+    // Read and return the file content
+    const content = await readFile(resolvedPath, 'utf8')
+    cache[cacheKey] = content // Store the result in the cache
+    return content
+  } catch (error) {
+    console.error('Error reading file:', error)
+    throw error // Re-throw the error to handle it in the calling function
+  }
+}
+
+export default {
+  getFileContentAsString,
+}

package/utils/wakatime.util.ts

@@ -0,0 +1,78 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import { HOME_DIR } from './node.util'
+import { Logger } from '@nestjs/common'
+
+// Define the file path (adjust as needed)
+const filePath: string = path.join(HOME_DIR, '.wakatime.cfg')
+
+// Define types
+type IniSection = Record<string, string>
+export type IniConfig = Record<string, IniSection>
+
+// Function to parse INI content
+export function parseIni(content: string): IniConfig {
+  const result: IniConfig = {}
+  const lines: string[] = content.split('\n')
+  let currentSection = ''
+
+  for (const line of lines) {
+    const trimmedLine: string = line.trim()
+    if (trimmedLine.startsWith('[') && trimmedLine.endsWith(']')) {
+      currentSection = trimmedLine.slice(1, -1)
+      result[currentSection] = {}
+    } else if (trimmedLine && currentSection) {
+      const [key, value] = trimmedLine.split('=').map((part) => part.trim())
+      if (key && value) {
+        result[currentSection][key] = value
+      }
+    }
+  }
+
+  return result
+}
+
+// Function to stringify INI content
+export function stringifyIni(data: IniConfig): string {
+  const entries = Object.entries(data)
+    .map(([section, entries]) => {
+      const sectionContent: string = Object.entries(entries)
+        .map(([key, value]) => `${key} = ${value}`)
+        .join('\n')
+      return `[${section}]\n${sectionContent}`
+    })
+    .join('\n\n')
+  return `${entries}\n`
+}
+
+export async function updateSettings(
+  newSettings: Record<string, string>,
+): Promise<void> {
+  try {
+    let config: IniConfig
+
+    try {
+      // Try to read the existing file
+      const data: string = await fs.readFile(filePath, 'utf8')
+      config = parseIni(data)
+    } catch (error) {
+      // File doesn't exist, create a new configuration
+      config = { settings: {} }
+    }
+
+    // Ensure the 'settings' section exists
+    if (!config.settings) {
+      config.settings = {}
+    }
+
+    // Update the settings
+    Object.assign(config.settings, newSettings)
+
+    // Write the updated content back to the file
+    const updatedContent: string = stringifyIni(config)
+    await fs.writeFile(filePath, updatedContent, 'utf8')
+    Logger.log('File updated successfully', 'WakatimeUtil')
+  } catch (error) {
+    Logger.error('Error updating file:', error)
+  }
+}