testing

Reviewed-on: #87

.dockerignore

@@ -0,0 +1,2 @@
+node_modules
+dist

.eslintrc.json

@@ -1,3 +0,0 @@
-{
-  "extends": ["next/core-web-vitals", "next/typescript"]
-}

.gitea/kubernetes/backend/deployment.yaml

@@ -0,0 +1,39 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: scoresaber-reloaded-backend
+  namespace: public-services
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: scoresaber-reloaded-backend
+  template:
+    metadata:
+      labels:
+        app: scoresaber-reloaded-backend
+    spec:
+      containers:
+        - name: scoresaber-reloaded-backend-container
+          image: git.fascinated.cc/fascinated/scoresaber-reloaded-backend:latest
+          imagePullPolicy: Always
+          ports:
+            - containerPort: 8080
+          resources:
+            requests:
+              cpu: 50m
+              memory: 128Mi
+            limits:
+              cpu: 1000m # 1 vCPU
+              memory: 512Mi
+          env:
+            - name: MONGO_URI
+              valueFrom:
+                secretKeyRef:
+                  name: ssr-backend-secret
+                  key: MONGO_URI
+            - name: DISCORD_BOT_TOKEN
+              valueFrom:
+                secretKeyRef:
+                  name: ssr-backend-secret
+                  key: DISCORD_BOT_TOKEN

.gitea/kubernetes/backend/ingress.yaml

@@ -0,0 +1,50 @@
+---
+apiVersion: traefik.io/v1alpha1
+kind: IngressRoute
+metadata:
+  name: scoresaber-reloaded-backend-ingress
+  namespace: public-services
+  annotations:
+    kubernetes.io/ingress.class: traefik-external
+spec:
+  entryPoints:
+    - websecure
+  routes:
+    - match: Host(`ssr.fascinated.cc`) && PathPrefix(`/api`)
+      kind: Rule
+      middlewares:
+        - name: default-headers
+          namespace: traefik
+        - name: compress
+          namespace: traefik
+        - name: scoresaber-reloaded-backend-strip-api-prefix
+          namespace: public-services
+      services:
+        - name: scoresaber-reloaded-backend-service
+          port: 8080
+  tls:
+    secretName: fascinated-cc
+---
+apiVersion: traefik.io/v1alpha1
+kind: IngressRoute
+metadata:
+  name: scoresaber-reloaded-backend-swagger-ingress
+  namespace: public-services
+  annotations:
+    kubernetes.io/ingress.class: traefik-external
+spec:
+  entryPoints:
+    - websecure
+  routes:
+    - match: Host(`ssr.fascinated.cc`) && PathPrefix(`/swagger`)
+      kind: Rule
+      middlewares:
+        - name: default-headers
+          namespace: traefik
+        - name: compress
+          namespace: traefik
+      services:
+        - name: scoresaber-reloaded-backend-service
+          port: 8080
+  tls:
+    secretName: fascinated-cc

.gitea/kubernetes/backend/sealed-secret.yaml

@@ -0,0 +1,17 @@
+---
+apiVersion: bitnami.com/v1alpha1
+kind: SealedSecret
+metadata:
+  creationTimestamp: null
+  name: ssr-backend-secret
+  namespace: public-services
+spec:
+  encryptedData:
+    DISCORD_BOT_TOKEN: AgCkl523hUe1qei/mybm16Eht0UVEJtPXbcnZYJ6aeLYkB2Mihk8OK+rYGnxN/1MhjYh4VNW36KPZ8/9M/chfsIirECw8OLNhhxzXxbyUpNCmy9JZA4EB5H6UDzC0STOOZekncGtGBg2cU0sZeHaYUlERbFSaDADuLx5aP2RxgHX5xucUfmTtMVbCDg2pCsVT+wliS3gD4FBTVYr1ZxePNCDpPsjzTCd6v+AzlZidIuNwZUDVcXIuCpA+o3jpbzuriMJDyGHA9H7182nZycQ0Q8KQLB1JYgZ2em3Sec5VM4Gkxd6d38c41ldgAIdPjd8rurpxpAdptDgMupmXx8Rm66BdFr0A4ifBpvmLePYOe6cOrjhfGhcEjkzLhBqEWZ7cH4oOKXRX5f0FLWCcKI5G7/vCbRfpr6jx4KuFQt2Mq+BplApVjz/lhqXigd+JDiXx383fYEMaZq8FB2mozfatw1/OpZrhMlunFmQPd/eOcBzJArwYY28qbWaTrKroA1Mc1yWGwlwIEpZAyoNN5x6XuLBKF5tkd+R0h1usDsxQoToHmfYN3qYktZRKsbPb1UpwBHeUPPzzIbgFUgAvGtPhqau4GH3VoCP6qNRt0ATiC8O0k9iXXPrPz9ajp5dzHPmjDz35AmBeoxsrpWZeWbYslc/iIEzqKWBmmXa/NAerJ0fVmMsC9bb+6CTVg7ZOTk0JC9moT5BP3F6U9ZYMkT8x99whvoLdautqnVpnYz/N0SwMVkJzQQKtFNxZH8eTuow8Eqyni2Im1/owMRX00SDtqTt1+8M12GDsnk=
+    MONGO_URI: AgCDR9Dasy7vtqThemJxCcXEAW+tNXpsSyBQeeF/tpE6Q6L1itl+8f4EEz+WUQ5cZf5HswD105hNZDhEaoqJeDFllmsYyEL7cZMgrsK1UyhY8m6H4+vdAkX4pBiGf0ig5RMkISopEHCyvmdDkO7vvfjsh2fyjBv0BD9KvqMfzg/m3dEbm48JXbBKogdN9H8yj3L4Xi/xaLwgGx8jnG8A0VoR3VmxJfSJKFOhovb5prS0ZByGAT0hrdGb0TgERfFLlsgjrKAiBx1xHgA+L0RPrkJCHXYT7z1ll/LYKfedLqIc76PTYZpMywq8XDIQUu0JnyZb1OzrjhK3zolzb+HIK65Rp4/PoM8yGyUwEbyJ/e6LBjsIjqtVoylYWy3css3xYmABaWD9FVl/qwXekOPJqc1dcOdEItlg34j+H01HXR1p0/SHZOYRTKM1mWNmlvP5nBd6gGue91LUIumonAP/dCUP4KBwaUkvJx+NW5w0L2DXG7ZHn18MUUx/zKgjFGl1GigyD5v/r2gfXXYjTTcdtR0oNHTjB3nBtU0142irJQCuqWuB3NWs8NTPfNp7/kTlHP8eD9NJfiSKCgU+Ld7sg+MBjnB5mVU3dX4WAdebfGZHaa4RIwyJbcvgu88sdSP+bzukcWi5cFppwuVX/4s9Aml+GtvuojmLbzuPAOIGKz5MS8TpB1v3Hiy5VFFO1OiWn53sT093kOp4OxULLWYtlTey9f2LzTbWz+X9oUOdedaVlQW445+eGmyKj9FDWrKk+7+wPhgYNY5EonN6p3OKkWopN3tv/TK3qcvT93uYBbr/sP9VT7GHnkdH2us=
+  template:
+    metadata:
+      creationTimestamp: null
+      name: ssr-backend-secret
+      namespace: public-services
+    type: Opaque

.gitea/kubernetes/backend/service.yaml

@@ -0,0 +1,13 @@
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: scoresaber-reloaded-backend-service
+  namespace: public-services
+spec:
+  type: ClusterIP
+  ports:
+    - port: 8080
+      targetPort: 8080
+  selector:
+    app: scoresaber-reloaded-backend

.gitea/kubernetes/backend/strip-api-prefix-middleware.yaml

@@ -0,0 +1,10 @@
+---
+apiVersion: traefik.io/v1alpha1
+kind: Middleware
+metadata:
+  name: scoresaber-reloaded-backend-strip-api-prefix
+  namespace: public-services
+spec:
+  stripPrefix:
+    prefixes:
+      - "/api"

.gitea/kubernetes/website/deployment.yaml

@@ -0,0 +1,28 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: scoresaber-reloaded-website
+  namespace: public-services
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: scoresaber-reloaded-website
+  template:
+    metadata:
+      labels:
+        app: scoresaber-reloaded-website
+    spec:
+      containers:
+        - name: scoresaber-reloaded-website-container
+          image: git.fascinated.cc/fascinated/scoresaber-reloaded-website:latest
+          imagePullPolicy: Always
+          ports:
+            - containerPort: 3000
+          resources:
+            requests:
+              cpu: 50m
+              memory: 128Mi
+            limits:
+              cpu: 1000m # 1 vCPU
+              memory: 1024Mi

.gitea/kubernetes/website/ingress.yaml

@@ -0,0 +1,24 @@
+---
+apiVersion: traefik.io/v1alpha1
+kind: IngressRoute
+metadata:
+  name: scoresaber-reloaded-website-ingress
+  namespace: public-services
+  annotations:
+    kubernetes.io/ingress.class: traefik-external
+spec:
+  entryPoints:
+    - websecure
+  routes:
+    - match: Host(`ssr.fascinated.cc`)
+      kind: Rule
+      middlewares:
+        - name: default-headers
+          namespace: traefik
+        - name: compress
+          namespace: traefik
+      services:
+        - name: scoresaber-reloaded-website-service
+          port: 3000
+  tls:
+    secretName: fascinated-cc

.gitea/kubernetes/website/service.yaml

@@ -0,0 +1,13 @@
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: scoresaber-reloaded-website-service
+  namespace: public-services
+spec:
+  type: ClusterIP
+  ports:
+    - port: 3000
+      targetPort: 3000
+  selector:
+    app: scoresaber-reloaded-website

.gitea/workflows/deploy-backend.yml

@@ -0,0 +1,98 @@
+name: Deploy Backend
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+    paths:
+      - projects/backend/**
+      - projects/common/**
+      - .gitea/workflows/deploy-backend.yml
+
+jobs:
+  docker:
+    strategy:
+      matrix:
+        arch: ["ubuntu-latest"]
+    runs-on: ${{ matrix.arch }}
+
+    # Steps to run
+    steps:
+      # Checkout the repo
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Deploy to Dokku
+      - name: Push to dokku
+        uses: dokku/github-action@master
+        with:
+          git_remote_url: "ssh://dokku@51.158.63.74:22/ssr-backend"
+          ssh_private_key: ${{ secrets.SSH_PRIVATE_KEY }}
+
+#name: "Deploy Backend"
+#
+#on:
+#  workflow_dispatch:
+#  push:
+#    branches:
+#      - master
+#    paths:
+#      - projects/backend/**
+#      - projects/common/**
+#      - .gitea/kubernetes/backend/**
+#      - .gitea/workflows/deploy-backend.yml
+#
+#jobs:
+#  deploy:
+#    runs-on: ubuntu-latest
+#    steps:
+#      - name: Checkout code
+#        uses: actions/checkout@v4
+#
+#      - name: Set up Docker Buildx
+#        uses: docker/setup-buildx-action@v3
+#
+#      - name: Login to Docker Hub
+#        uses: docker/login-action@v3
+#        with:
+#          username: ${{ secrets.REGISTRY_USERNAME }}
+#          password: ${{ secrets.REGISTRY_TOKEN }}
+#          registry: git.fascinated.cc
+#
+#      - name: Build Image
+#        uses: docker/build-push-action@v6
+#        with:
+#          context: .
+#          file: ./projects/backend/Dockerfile
+#          push: true
+#          tags: |
+#            git.fascinated.cc/fascinated/scoresaber-reloaded-backend:${{ github.sha }}
+#            git.fascinated.cc/fascinated/scoresaber-reloaded-backend:latest
+#          build-args: |
+#            GIT_REV=${{ gitea.sha }}
+#
+#      - name: Install kubectl
+#        uses: azure/setup-kubectl@v4
+#        id: install
+#
+#      - name: Setup Kubernetes Context
+#        uses: azure/k8s-set-context@v4
+#        with:
+#          kubeconfig: ${{ secrets.KUBECONFIG }}
+#
+#      - name: Deploy to Kubernetes
+#        uses: Azure/k8s-deploy@v5
+#        with:
+#          action: deploy
+#          namespace: public-services
+#          manifests: |
+#            .gitea/kubernetes/backend/sealed-secret.yaml
+#            .gitea/kubernetes/backend/deployment.yaml
+#            .gitea/kubernetes/backend/service.yaml
+#            .gitea/kubernetes/backend/strip-api-prefix-middleware.yaml
+#            .gitea/kubernetes/backend/ingress.yaml
+#          images: |
+#            git.fascinated.cc/fascinated/scoresaber-reloaded-backend:${{ github.sha }}

.gitea/workflows/deploy-website.yml

@@ -0,0 +1,97 @@
+name: Deploy Website
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+    paths:
+      - projects/website/**
+      - projects/common/**
+      - .gitea/workflows/deploy-website.yml
+
+jobs:
+  docker:
+    strategy:
+      matrix:
+        arch: ["ubuntu-latest"]
+    runs-on: ${{ matrix.arch }}
+
+    # Steps to run
+    steps:
+      # Checkout the repo
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Deploy to Dokku
+      - name: Push to dokku
+        uses: dokku/github-action@master
+        with:
+          git_remote_url: "ssh://dokku@51.158.63.74:22/ssr-website"
+          ssh_private_key: ${{ secrets.SSH_PRIVATE_KEY }}
+
+#name: "Deploy Website"
+#
+#on:
+#  workflow_dispatch:
+#  push:
+#    branches:
+#      - master
+#    paths:
+#      - projects/website/**
+#      - projects/common/**
+#      - .gitea/kubernetes/website/**
+#      - .gitea/workflows/deploy-website.yml
+#
+#jobs:
+#  deploy:
+#    runs-on: ubuntu-latest
+#    steps:
+#      - name: Checkout code
+#        uses: actions/checkout@v4
+#
+#      - name: Set up Docker Buildx
+#        uses: docker/setup-buildx-action@v3
+#
+#      - name: Login to Docker Hub
+#        uses: docker/login-action@v3
+#        with:
+#          username: ${{ secrets.REGISTRY_USERNAME }}
+#          password: ${{ secrets.REGISTRY_TOKEN }}
+#          registry: git.fascinated.cc
+#
+#      - name: Build Image
+#        uses: docker/build-push-action@v6
+#        with:
+#          context: .
+#          file: ./projects/website/Dockerfile
+#          push: true
+#          tags: |
+#            git.fascinated.cc/fascinated/scoresaber-reloaded-website:${{ github.sha }}
+#            git.fascinated.cc/fascinated/scoresaber-reloaded-website:latest
+#          build-args: |
+#            GIT_REV=${{ gitea.sha }}
+#            SENTRY_AUTH_TOKEN=${{ secrets.SENTRY_AUTH_TOKEN }}
+#
+#      - name: Install kubectl
+#        uses: azure/setup-kubectl@v4
+#        id: install
+#
+#      - name: Setup Kubernetes Context
+#        uses: azure/k8s-set-context@v4
+#        with:
+#          kubeconfig: ${{ secrets.KUBECONFIG }}
+#
+#      - name: Deploy to Kubernetes
+#        uses: Azure/k8s-deploy@v5
+#        with:
+#          action: deploy
+#          namespace: public-services
+#          manifests: |
+#            .gitea/kubernetes/website/deployment.yaml
+#            .gitea/kubernetes/website/service.yaml
+#            .gitea/kubernetes/website/ingress.yaml
+#          images: |
+#            git.fascinated.cc/fascinated/scoresaber-reloaded-website:${{ github.sha }}

.gitea/workflows/deploy.yml

@@ -1,21 +0,0 @@
-name: "Deploy SSR"
-
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  deploy:
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Cloning repo
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Push to dokku
-        uses: dokku/github-action@master
-        with:
-          git_remote_url: "ssh://dokku@10.0.50.65:22/ssr"
-          ssh_private_key: ${{ secrets.SSH_PRIVATE_KEY }}

.gitignore

@@ -1,36 +1,81 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
-
-# dependencies
-/node_modules
-/.pnp
-.pnp.js
-.yarn/install-state.gz
-
-# testing
-/coverage
-
-# next.js
-/.next/
-/out/
-
-# production
-/build
-
-# misc
-.DS_Store
-*.pem
-
-# debug
+logs
+*.log
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
-
-# local env files
-.env*.local
-
-# vercel
-.vercel
-
-# typescript
+lerna-debug.log*
+.pnpm-debug.log*
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+pids
+*.pid
+*.seed
+*.pid.lock
+lib-cov
+coverage
+*.lcov
+.nyc_output
+.grunt
+bower_components
+.lock-wscript
+build/Release
+node_modules/
+jspm_packages/
+web_modules/
 *.tsbuildinfo
+.npm
+.eslintcache
+.stylelintcache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+.node_repl_history
+*.tgz
+.yarn-integrity
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+.cache
+.parcel-cache
+.next
+out
+.nuxt
+dist
+.cache/
+.vuepress/dist
+.temp
+.docusaurus
+.serverless/
+.fusebox/
+.dynamodb/
+.tern-port
+.vscode-test
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+.DS_*
+**/*.backup.*
+**/*.back.*
+node_modules
+*.sublime*
+psd
+thumb
+sketch
+/node_modules
+/.pnp
+.pnp.js
+/coverage
+/.next/
+/out/
+/build
+.DS_Store
+*.pem
+.env*.local
+.vercel
 next-env.d.ts
+.idea
+secret.yaml

.prettierrc.json

@@ -0,0 +1,12 @@
+{
+  "semi": true,
+  "tabWidth": 2,
+  "useTabs": false,
+  "singleQuote": false,
+  "trailingComma": "es5",
+  "printWidth": 120,
+  "bracketSpacing": true,
+  "arrowParens": "avoid",
+  "jsxSingleQuote": false,
+  "jsxBracketSameLine": false
+}

Dockerfile

@@ -1,43 +0,0 @@
-FROM fascinated/docker-images:node-pnpm-latest AS base
-
-# Install depends
-FROM base AS deps
-RUN apk add --no-cache libc6-compat
-WORKDIR /app
-COPY package.json* pnpm-lock.yaml* ./
-RUN pnpm install --frozen-lockfile --quiet
-
-# Build from source
-FROM base AS builder
-WORKDIR /app
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-ENV NEXT_TELEMETRY_DISABLED 1
-
-# Build the app
-RUN pnpm run build
-
-# Run the app
-FROM base AS runner
-WORKDIR /app
-
-ENV NODE_ENV production
-ENV NEXT_TELEMETRY_DISABLED 1
-
-RUN addgroup --system --gid 1001 nodejs
-RUN adduser --system --uid 1001 nextjs
-
-RUN mkdir .next
-RUN chown nextjs:nodejs .next
-
-COPY --from=builder --chown=nextjs:nodejs /app/node_modules ./node_modules
-COPY --from=builder --chown=nextjs:nodejs /app/.next ./.next
-COPY --from=builder --chown=nextjs:nodejs /app/public ./public
-COPY --from=builder --chown=nextjs:nodejs /app/package.json ./package.json
-COPY --from=builder --chown=nextjs:nodejs /app/next.config.mjs ./next.config.mjs
-
-USER nextjs
-EXPOSE 80
-ENV HOSTNAME "0.0.0.0"
-ENV PORT 80
-CMD ["pnpm", "start"]

config.ts

@@ -1,3 +0,0 @@
-export const config = {
-  siteUrl: "https://ssr-dev.fascinated.cc",
-};

next.config.mjs

@@ -1,4 +0,0 @@
-/** @type {import('next').NextConfig} */
-const nextConfig = {};
-
-export default nextConfig;

package.json

@@ -1,50 +1,19 @@
 {
-  "name": "scoresaber-reloadedv3",
-  "version": "0.1.0",
-  "private": true,
+  "name": "scoresaber-reloaded",
+  "version": "1.0.0",
+  "workspaces": [
+    "projects/*"
+  ],
   "scripts": {
-    "dev": "next dev",
-    "build": "next build",
-    "start": "next start",
-    "lint": "next lint"
+    "dev:website": "bun --filter 'website' dev",
+    "dev:backend": "bun --filter 'backend' dev",
+    "dev:common": "bun --filter '@ssr/common' dev",
+    "dev": "concurrently \"bun run dev:common\" \"bun run dev:backend\""
   },
+  "author": "fascinated7",
+  "license": "MIT",
   "dependencies": {
-    "@formkit/tempo": "^0.1.2",
-    "@heroicons/react": "^2.1.5",
-    "@hookform/resolvers": "^3.9.0",
-    "@radix-ui/react-avatar": "^1.1.0",
-    "@radix-ui/react-icons": "^1.3.0",
-    "@radix-ui/react-label": "^2.1.0",
-    "@radix-ui/react-scroll-area": "^1.1.0",
-    "@radix-ui/react-slot": "^1.1.0",
-    "@radix-ui/react-toast": "^1.2.1",
-    "@radix-ui/react-tooltip": "^1.1.2",
-    "@tanstack/react-query": "^5.55.4",
-    "chart.js": "^4.4.4",
-    "class-variance-authority": "^0.7.0",
-    "clsx": "^2.1.1",
-    "dexie": "^4.0.8",
-    "dexie-react-hooks": "^1.1.7",
-    "ky": "^1.7.2",
-    "lucide-react": "^0.439.0",
-    "next": "14.2.8",
-    "next-themes": "^0.3.0",
-    "react": "^18",
-    "react-chartjs-2": "^5.2.0",
-    "react-dom": "^18",
-    "react-hook-form": "^7.53.0",
-    "tailwind-merge": "^2.5.2",
-    "tailwindcss-animate": "^1.0.7",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/node": "^20",
-    "@types/react": "^18",
-    "@types/react-dom": "^18",
-    "eslint": "^8",
-    "eslint-config-next": "14.2.8",
-    "postcss": "^8",
-    "tailwindcss": "^3.4.1",
-    "typescript": "^5"
+    "concurrently": "^9.0.1",
+    "cross-env": "^7.0.3"
   }
 }

projects/backend/.dockerignore

@@ -0,0 +1,2 @@
+node_modules
+dist

projects/backend/.env-example

@@ -0,0 +1,2 @@
+MONGO_URI=mongodb://localhost:27017
+API_URL=http://localhost:8080

projects/backend/.eslintrc.json

@@ -0,0 +1,20 @@
+{
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+    }
+}

projects/backend/.gitignore

@@ -0,0 +1,44 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# vercel
+.vercel
+
+**/*.trace
+**/*.zip
+**/*.tar.gz
+**/*.tgz
+**/*.log
+package-lock.json
+**/*.bun
+
+.env

projects/backend/Dockerfile

@@ -0,0 +1,34 @@
+FROM oven/bun:1.1.33-alpine AS base
+
+# Install dependencies
+FROM base AS depends
+WORKDIR /app
+COPY . .
+RUN bun install --frozen-lockfile
+
+# Run the app
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV production
+
+# Copy the depends
+COPY --from=depends /app/package.json* /app/bun.lockb* ./
+COPY --from=depends /app/node_modules ./node_modules
+
+# Build the common library
+COPY --from=depends /app/projects/common ./projects/common
+RUN bun i -g typescript
+RUN bun --filter '@ssr/common' build
+
+# Copy the backend project
+COPY --from=depends /app/projects/backend ./projects/backend
+
+# Lint before starting
+RUN bun --filter 'backend' lint
+
+ARG PORT=8080
+ENV PORT $PORT
+EXPOSE $PORT
+
+CMD ["bun", "run", "--filter", "backend", "start"]

projects/backend/README.md

@@ -0,0 +1,9 @@
+# Backend
+
+## Development
+To start the development server run:
+```bash
+bun run dev
+```
+
+Open http://localhost:3000/ with your browser to see the result.

projects/backend/components/globe-icon.tsx

@@ -0,0 +1,20 @@
+import React from "react";
+
+export const GlobeIcon = () => (
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    viewBox="0 0 24 26"
+    fill="currentColor"
+    style={{
+      width: "33px",
+      height: "33px",
+      paddingRight: "3px",
+    }}
+  >
+    <path
+      fillRule="evenodd"
+      d="M12 2.25c-5.385 0-9.75 4.365-9.75 9.75s4.365 9.75 9.75 9.75 9.75-4.365 9.75-9.75S17.385 2.25 12 2.25ZM6.262 6.072a8.25 8.25 0 1 0 10.562-.766 4.5 4.5 0 0 1-1.318 1.357L14.25 7.5l.165.33a.809.809 0 0 1-1.086 1.085l-.604-.302a1.125 1.125 0 0 0-1.298.21l-.132.131c-.439.44-.439 1.152 0 1.591l.296.296c.256.257.622.374.98.314l1.17-.195c.323-.054.654.036.905.245l1.33 1.108c.32.267.46.694.358 1.1a8.7 8.7 0 0 1-2.288 4.04l-.723.724a1.125 1.125 0 0 1-1.298.21l-.153-.076a1.125 1.125 0 0 1-.622-1.006v-1.089c0-.298-.119-.585-.33-.796l-1.347-1.347a1.125 1.125 0 0 1-.21-1.298L9.75 12l-1.64-1.64a6 6 0 0 1-1.676-3.257l-.172-1.03Z"
+      clipRule="evenodd"
+    />
+  </svg>
+);

projects/backend/components/star-icon.tsx

@@ -0,0 +1,20 @@
+import React from "react";
+
+export const StarIcon = () => (
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    viewBox="0 0 24 24"
+    fill="currentColor"
+    style={{
+      width: "40px",
+      height: "40px",
+      paddingRight: "3px",
+    }}
+  >
+    <path
+      fillRule="evenodd"
+      d="M10.788 3.21c.448-1.077 1.976-1.077 2.424 0l2.082 5.006 5.404.434c1.164.093 1.636 1.545.749 2.305l-4.117 3.527 1.257 5.273c.271 1.136-.964 2.033-1.96 1.425L12 18.354 7.373 21.18c-.996.608-2.231-.29-1.96-1.425l1.257-5.273-4.117-3.527c-.887-.76-.415-2.212.749-2.305l5.404-.434 2.082-5.005Z"
+      clipRule="evenodd"
+    />
+  </svg>
+);

projects/backend/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "bun run --watch src/index.ts",
+    "start": "bun run src/index.ts",
+    "lint": "eslint src/**/*.ts"
+  },
+  "dependencies": {
+    "@bogeychan/elysia-etag": "^0.0.6",
+    "@dotenvx/dotenvx": "^1.16.1",
+    "@elysiajs/cors": "^1.1.1",
+    "@elysiajs/cron": "^1.1.1",
+    "@elysiajs/swagger": "^1.1.3",
+    "@ssr/common": "workspace:common",
+    "@tqman/nice-logger": "^1.0.1",
+    "@typegoose/auto-increment": "^4.7.0",
+    "@typegoose/typegoose": "^12.8.0",
+    "@typescript-eslint/eslint-plugin": "^8.9.0",
+    "@typescript-eslint/parser": "^8.9.0",
+    "@vercel/og": "^0.6.3",
+    "discordx": "^11.12.1",
+    "elysia": "latest",
+    "elysia-autoroutes": "^0.5.0",
+    "elysia-decorators": "^1.0.2",
+    "elysia-helmet": "^2.0.0",
+    "eslint": "^8.57.1",
+    "extract-colors": "^4.1.0",
+    "jimp": "^1.6.0",
+    "ky": "^1.7.2",
+    "mongoose": "^8.7.0",
+    "node-cache": "^5.1.2",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "bun-types": "latest"
+  },
+  "module": "src/index.js"
+}

projects/backend/src/bot/bot.ts

@@ -0,0 +1,54 @@
+import { Client, MetadataStorage } from "discordx";
+import { ActivityType, EmbedBuilder } from "discord.js";
+import { Config } from "@ssr/common/config";
+
+export enum DiscordChannels {
+  trackedPlayerLogs = "1295985197262569512",
+  numberOneFeed = "1295988063817830430",
+  backendLogs = "1296524935237468250",
+}
+
+const DiscordBot = new Client({
+  intents: [],
+  presence: {
+    status: "online",
+
+    activities: [
+      {
+        name: "scores...",
+        type: ActivityType.Watching,
+        url: "https://ssr.fascinated.cc",
+      },
+    ],
+  },
+});
+
+DiscordBot.once("ready", () => {
+  console.log("Discord bot ready!");
+});
+
+export function initDiscordBot() {
+  console.log("Initializing discord bot...");
+
+  MetadataStorage.instance.build().then(async () => {
+    await DiscordBot.login(Config.discordBotToken!).then();
+  });
+}
+
+/**
+ * Logs the message to a discord channel.
+ *
+ * @param channelId the channel id to log to
+ * @param message the message to log
+ */
+export async function logToChannel(channelId: DiscordChannels, message: EmbedBuilder) {
+  const channel = await DiscordBot.channels.fetch(channelId);
+  if (channel == undefined) {
+    throw new Error(`Channel "${channelId}" not found`);
+  }
+  if (!channel.isSendable()) {
+    throw new Error(`Channel "${channelId}" is not sendable`);
+  }
+
+  channel.send({ embeds: [message] });
+}

projects/backend/src/common/app.util.ts

@@ -0,0 +1,10 @@
+/**
+ * Gets the app version.
+ */
+export async function getAppVersion() {
+  if (!process.env.APP_VERSION) {
+    const packageJson = await import("../../package.json");
+    process.env.APP_VERSION = packageJson.version;
+  }
+  return process.env.APP_VERSION + "-" + (process.env.GIT_REV?.substring(0, 7) ?? "dev");
+}

projects/backend/src/common/cache.util.ts

@@ -0,0 +1,35 @@
+import { SSRCache } from "@ssr/common/cache";
+import { InternalServerError } from "../error/internal-server-error";
+import { isProduction } from "@ssr/common/utils/utils";
+
+/**
+ * Fetches data with caching.
+ *
+ * @param cache the cache to fetch from
+ * @param cacheKey The key used for caching.
+ * @param fetchFn The function to fetch data if it's not in cache.
+ */
+export async function fetchWithCache<T>(
+  cache: SSRCache,
+  cacheKey: string,
+  fetchFn: () => Promise<T | undefined>
+): Promise<T | undefined> {
+  if (!isProduction()) {
+    return await fetchFn();
+  }
+
+  if (cache == undefined) {
+    throw new InternalServerError(`Cache is not defined`);
+  }
+
+  if (cache.has(cacheKey)) {
+    return cache.get<T>(cacheKey);
+  }
+
+  const data = await fetchFn();
+  if (data) {
+    cache.set(cacheKey, data);
+  }
+
+  return data;
+}

projects/backend/src/common/http-codes.ts

@@ -0,0 +1,75 @@
+export const HttpCode = {
+  // 1xx Informational
+  CONTINUE: { code: 100, message: "Continue" },
+  SWITCHING_PROTOCOLS: { code: 101, message: "Switching Protocols" },
+  PROCESSING: { code: 102, message: "Processing" },
+  EARLY_HINTS: { code: 103, message: "Early Hints" },
+
+  // 2xx Success
+  OK: { code: 200, message: "OK" },
+  CREATED: { code: 201, message: "Created" },
+  ACCEPTED: { code: 202, message: "Accepted" },
+  NON_AUTHORITATIVE_INFORMATION: { code: 203, message: "Non-Authoritative Information" },
+  NO_CONTENT: { code: 204, message: "No Content" },
+  RESET_CONTENT: { code: 205, message: "Reset Content" },
+  PARTIAL_CONTENT: { code: 206, message: "Partial Content" },
+  MULTI_STATUS: { code: 207, message: "Multi-Status" },
+  ALREADY_REPORTED: { code: 208, message: "Already Reported" },
+  IM_USED: { code: 226, message: "IM Used" },
+
+  // 3xx Redirection
+  MULTIPLE_CHOICES: { code: 300, message: "Multiple Choices" },
+  MOVED_PERMANENTLY: { code: 301, message: "Moved Permanently" },
+  FOUND: { code: 302, message: "Found" },
+  SEE_OTHER: { code: 303, message: "See Other" },
+  NOT_MODIFIED: { code: 304, message: "Not Modified" },
+  USE_PROXY: { code: 305, message: "Use Proxy" },
+  TEMPORARY_REDIRECT: { code: 307, message: "Temporary Redirect" },
+  PERMANENT_REDIRECT: { code: 308, message: "Permanent Redirect" },
+
+  // 4xx Client Errors
+  BAD_REQUEST: { code: 400, message: "Bad Request" },
+  UNAUTHORIZED: { code: 401, message: "Unauthorized" },
+  PAYMENT_REQUIRED: { code: 402, message: "Payment Required" },
+  FORBIDDEN: { code: 403, message: "Forbidden" },
+  NOT_FOUND: { code: 404, message: "Not Found" },
+  METHOD_NOT_ALLOWED: { code: 405, message: "Method Not Allowed" },
+  NOT_ACCEPTABLE: { code: 406, message: "Not Acceptable" },
+  PROXY_AUTHENTICATION_REQUIRED: { code: 407, message: "Proxy Authentication Required" },
+  REQUEST_TIMEOUT: { code: 408, message: "Request Timeout" },
+  CONFLICT: { code: 409, message: "Conflict" },
+  GONE: { code: 410, message: "Gone" },
+  LENGTH_REQUIRED: { code: 411, message: "Length Required" },
+  PRECONDITION_FAILED: { code: 412, message: "Precondition Failed" },
+  PAYLOAD_TOO_LARGE: { code: 413, message: "Payload Too Large" },
+  URI_TOO_LONG: { code: 414, message: "URI Too Long" },
+  UNSUPPORTED_MEDIA_TYPE: { code: 415, message: "Unsupported Media Type" },
+  RANGE_NOT_SATISFIABLE: { code: 416, message: "Range Not Satisfiable" },
+  EXPECTATION_FAILED: { code: 417, message: "Expectation Failed" },
+  IM_A_TEAPOT: { code: 418, message: "I'm a teapot" },
+  MISDIRECTED_REQUEST: { code: 421, message: "Misdirected Request" },
+  UNPROCESSABLE_ENTITY: { code: 422, message: "Unprocessable Entity" },
+  LOCKED: { code: 423, message: "Locked" },
+  FAILED_DEPENDENCY: { code: 424, message: "Failed Dependency" },
+  TOO_EARLY: { code: 425, message: "Too Early" },
+  UPGRADE_REQUIRED: { code: 426, message: "Upgrade Required" },
+  PRECONDITION_REQUIRED: { code: 428, message: "Precondition Required" },
+  TOO_MANY_REQUESTS: { code: 429, message: "Too Many Requests" },
+  REQUEST_HEADER_FIELDS_TOO_LARGE: { code: 431, message: "Request Header Fields Too Large" },
+  UNAVAILABLE_FOR_LEGAL_REASONS: { code: 451, message: "Unavailable For Legal Reasons" },
+
+  // 5xx Server Errors
+  INTERNAL_SERVER_ERROR: { code: 500, message: "Internal Server Error" },
+  NOT_IMPLEMENTED: { code: 501, message: "Not Implemented" },
+  BAD_GATEWAY: { code: 502, message: "Bad Gateway" },
+  SERVICE_UNAVAILABLE: { code: 503, message: "Service Unavailable" },
+  GATEWAY_TIMEOUT: { code: 504, message: "Gateway Timeout" },
+  HTTP_VERSION_NOT_SUPPORTED: { code: 505, message: "HTTP Version Not Supported" },
+  VARIANT_ALSO_NEGOTIATES: { code: 506, message: "Variant Also Negotiates" },
+  INSUFFICIENT_STORAGE: { code: 507, message: "Insufficient Storage" },
+  LOOP_DETECTED: { code: 508, message: "Loop Detected" },
+  NOT_EXTENDED: { code: 510, message: "Not Extended" },
+  NETWORK_AUTHENTICATION_REQUIRED: { code: 511, message: "Network Authentication Required" },
+} as const;
+
+export type HttpCode = typeof HttpCode[keyof typeof HttpCode];

projects/backend/src/controller/app.controller.ts

@@ -0,0 +1,26 @@
+import { Controller, Get } from "elysia-decorators";
+import { getAppVersion } from "../common/app.util";
+import { AppService } from "../service/app.service";
+
+@Controller()
+export default class AppController {
+  @Get("/")
+  public async index() {
+    return {
+      app: "backend",
+      version: await getAppVersion(),
+    };
+  }
+
+  @Get("/health")
+  public async getHealth() {
+    return {
+      status: "OK",
+    };
+  }
+
+  @Get("/statistics")
+  public async getStatistics() {
+    return await AppService.getAppStatistics();
+  }
+}

projects/backend/src/controller/image.controller.ts

@@ -0,0 +1,36 @@
+import { Controller, Get } from "elysia-decorators";
+import { t } from "elysia";
+import { ImageService } from "../service/image.service";
+
+@Controller("/image")
+export default class ImageController {
+  @Get("/averagecolor/:url", {
+    config: {},
+    params: t.Object({
+      url: t.String({ required: true }),
+    }),
+  })
+  public async getImageAverageColor({ params: { url } }: { params: { url: string } }) {
+    return await ImageService.getAverageImageColor(url);
+  }
+
+  @Get("/player/:id", {
+    config: {},
+    params: t.Object({
+      id: t.String({ required: true }),
+    }),
+  })
+  public async getPlayerImage({ params: { id } }: { params: { id: string } }) {
+    return await ImageService.generatePlayerImage(id);
+  }
+
+  @Get("/leaderboard/:id", {
+    config: {},
+    params: t.Object({
+      id: t.String({ required: true }),
+    }),
+  })
+  public async getLeaderboardImage({ params: { id } }: { params: { id: string } }) {
+    return await ImageService.generateLeaderboardImage(id);
+  }
+}

projects/backend/src/controller/leaderboard.controller.ts

@@ -0,0 +1,26 @@
+import { Controller, Get } from "elysia-decorators";
+import { t } from "elysia";
+import { Leaderboards } from "@ssr/common/leaderboard";
+import LeaderboardService from "../service/leaderboard.service";
+
+@Controller("/leaderboard")
+export default class LeaderboardController {
+  @Get("/:leaderboard/:id", {
+    config: {},
+    params: t.Object({
+      id: t.String({ required: true }),
+      leaderboard: t.String({ required: true }),
+    }),
+  })
+  public async getLeaderboard({
+    params: { leaderboard, id },
+  }: {
+    params: {
+      leaderboard: Leaderboards;
+      id: string;
+      page: number;
+    };
+  }): Promise<unknown> {
+    return await LeaderboardService.getLeaderboard(leaderboard, id);
+  }
+}

projects/backend/src/controller/player.controller.ts

@@ -0,0 +1,80 @@
+import { Controller, Get } from "elysia-decorators";
+import { PlayerService } from "../service/player.service";
+import { t } from "elysia";
+import { PlayerHistory } from "@ssr/common/player/player-history";
+import { PlayerTrackedSince } from "@ssr/common/player/player-tracked-since";
+import { AroundPlayerResponse } from "@ssr/common/response/around-player-response";
+
+@Controller("/player")
+export default class PlayerController {
+  @Get("/history/:id/:days", {
+    config: {},
+    params: t.Object({
+      id: t.String({ required: true }),
+      days: t.Number({ default: 50, required: false }),
+    }),
+    query: t.Object({
+      createIfMissing: t.Boolean({ default: false, required: false }),
+    }),
+  })
+  public async getPlayer({
+    params: { id, days },
+    query: { createIfMissing },
+  }: {
+    params: { id: string; days: number };
+    query: { createIfMissing: boolean };
+  }): Promise<{ statistics: Record<string, PlayerHistory> }> {
+    if (days < 1) {
+      days = 1;
+    }
+    // Limit to 10 years
+    if (days > 365 * 10) {
+      days = 365 * 10;
+    }
+    const player = await PlayerService.getPlayer(id, createIfMissing);
+    return { statistics: player.getHistoryPreviousDays(days) };
+  }
+
+  @Get("/tracked/:id", {
+    config: {},
+    params: t.Object({
+      id: t.String({ required: true }),
+    }),
+  })
+  public async getTrackedStatus({
+    params: { id },
+    query: { createIfMissing },
+  }: {
+    params: { id: string };
+    query: { createIfMissing: boolean };
+  }): Promise<PlayerTrackedSince> {
+    try {
+      const player = await PlayerService.getPlayer(id, createIfMissing);
+      return {
+        tracked: true,
+        daysTracked: player.getDaysTracked(),
+      };
+    } catch {
+      return {
+        tracked: false,
+      };
+    }
+  }
+
+  @Get("/around/:id/:type", {
+    config: {},
+    params: t.Object({
+      id: t.String({ required: true }),
+      type: t.String({ required: true }),
+    }),
+  })
+  public async getPlayersAround({
+    params: { id, type },
+  }: {
+    params: { id: string; type: "global" | "country" };
+  }): Promise<AroundPlayerResponse> {
+    return {
+      players: await PlayerService.getPlayersAroundPlayer(id, type),
+    };
+  }
+}

projects/backend/src/controller/scores.controller.ts

@@ -0,0 +1,59 @@
+import { Controller, Get } from "elysia-decorators";
+import { t } from "elysia";
+import { Leaderboards } from "@ssr/common/leaderboard";
+import { ScoreService } from "../service/score.service";
+import { ScoreSortType } from "@ssr/common/sorter/sort-type";
+import { SortDirection } from "@ssr/common/sorter/sort-direction";
+
+@Controller("/scores")
+export default class ScoresController {
+  @Get("/player/:leaderboard/:id/:page/:sort/:direction", {
+    config: {},
+    params: t.Object({
+      leaderboard: t.String({ required: true }),
+      id: t.String({ required: true }),
+      page: t.Number({ required: true }),
+      sort: t.String({ required: true }),
+      direction: t.String({ required: true }),
+    }),
+    query: t.Object({
+      search: t.Optional(t.String()),
+    }),
+  })
+  public async getScores({
+    params: { leaderboard, id, page, sort, direction },
+    query: { search },
+  }: {
+    params: {
+      leaderboard: Leaderboards;
+      id: string;
+      page: number;
+      sort: ScoreSortType;
+      direction: SortDirection;
+    };
+    query: { search?: string };
+  }): Promise<unknown> {
+    return await ScoreService.getPlayerScores(leaderboard, id, page, sort, direction, search);
+  }
+
+  @Get("/leaderboard/:leaderboard/:id/:page", {
+    config: {},
+    params: t.Object({
+      leaderboard: t.String({ required: true }),
+      id: t.String({ required: true }),
+      page: t.Number({ required: true }),
+    }),
+  })
+  public async getLeaderboardScores({
+    params: { leaderboard, id, page },
+  }: {
+    params: {
+      leaderboard: Leaderboards;
+      id: string;
+      page: number;
+    };
+    query: { search?: string };
+  }): Promise<unknown> {
+    return await ScoreService.getLeaderboardScores(leaderboard, id, page);
+  }
+}

projects/backend/src/error/internal-server-error.ts

@@ -0,0 +1,10 @@
+import { HttpCode } from "../common/http-codes";
+
+export class InternalServerError extends Error {
+  constructor(
+    public message: string = "internal-server-error",
+    public status: number = HttpCode.INTERNAL_SERVER_ERROR.code
+  ) {
+    super(message);
+  }
+}

projects/backend/src/error/not-found-error.ts

@@ -0,0 +1,10 @@
+import { HttpCode } from "../common/http-codes";
+
+export class NotFoundError extends Error {
+  constructor(
+    public message: string = "not-found",
+    public status: number = HttpCode.NOT_FOUND.code
+  ) {
+    super(message);
+  }
+}

projects/backend/src/error/rate-limit-error.ts

@@ -0,0 +1,10 @@
+import { HttpCode } from "../common/http-codes";
+
+export class RateLimitError extends Error {
+  constructor(
+    public message: string = "rate-limited",
+    public status: number = HttpCode.TOO_MANY_REQUESTS.code
+  ) {
+    super(message);
+  }
+}

projects/backend/src/index.ts

@@ -0,0 +1,238 @@
+import { Elysia } from "elysia";
+import cors from "@elysiajs/cors";
+import { decorators } from "elysia-decorators";
+import { logger } from "@tqman/nice-logger";
+import { swagger } from "@elysiajs/swagger";
+import { helmet } from "elysia-helmet";
+import { etag } from "@bogeychan/elysia-etag";
+import AppController from "./controller/app.controller";
+import * as dotenv from "@dotenvx/dotenvx";
+import mongoose from "mongoose";
+import PlayerController from "./controller/player.controller";
+import { PlayerService } from "./service/player.service";
+import { cron } from "@elysiajs/cron";
+import { scoresaberService } from "@ssr/common/service/impl/scoresaber";
+import { delay, isProduction } from "@ssr/common/utils/utils";
+import ImageController from "./controller/image.controller";
+import { ScoreService } from "./service/score.service";
+import { Config } from "@ssr/common/config";
+import { PlayerDocument, PlayerModel } from "@ssr/common/model/player";
+import ScoresController from "./controller/scores.controller";
+import LeaderboardController from "./controller/leaderboard.controller";
+import { getAppVersion } from "./common/app.util";
+import { connectScoresaberWebsocket } from "@ssr/common/websocket/scoresaber-websocket";
+import { connectBeatLeaderWebsocket } from "@ssr/common/websocket/beatleader-websocket";
+import { DiscordChannels, initDiscordBot, logToChannel } from "./bot/bot";
+import { EmbedBuilder } from "discord.js";
+import { ScoreSort } from "@ssr/common/score/score-sort";
+
+// Load .env file
+dotenv.config({
+  logLevel: (await Bun.file(".env").exists()) ? "success" : "warn",
+  path: ".env",
+  override: true,
+});
+
+// Connect to Mongo
+await mongoose.connect(Config.mongoUri!); // Connect to MongoDB
+
+// Connect to websockets
+connectScoresaberWebsocket({
+  onScore: async score => {
+    await ScoreService.trackScoreSaberScore(score.score, score.leaderboard);
+    await ScoreService.updatePlayerScoresSet(score);
+
+    await ScoreService.notifyNumberOne(score);
+  },
+  onDisconnect: async error => {
+    await logToChannel(
+      DiscordChannels.backendLogs,
+      new EmbedBuilder().setDescription(`ScoreSaber websocket disconnected: ${JSON.stringify(error)}`)
+    );
+  },
+});
+connectBeatLeaderWebsocket({
+  onScore: async score => {
+    await ScoreService.trackBeatLeaderScore(score);
+  },
+  onDisconnect: async error => {
+    await logToChannel(
+      DiscordChannels.backendLogs,
+      new EmbedBuilder().setDescription(`BeatLeader websocket disconnected: ${JSON.stringify(error)}`)
+    );
+  },
+});
+
+export const app = new Elysia();
+app.use(
+  cron({
+    name: "player-statistics-tracker-cron",
+    pattern: "1 0 * * *", // Every day at 00:01
+    timezone: "Europe/London", // UTC time
+    run: async () => {
+      const pages = 20; // top 1000 players
+      const cooldown = 60_000 / 250; // 250 requests per minute
+
+      let toTrack: PlayerDocument[] = await PlayerModel.find({});
+      const toRemoveIds: string[] = [];
+
+      // loop through pages to fetch the top players
+      console.log(`Fetching ${pages} pages of players from ScoreSaber...`);
+      for (let i = 0; i < pages; i++) {
+        const pageNumber = i + 1;
+        console.log(`Fetching page ${pageNumber}...`);
+        const page = await scoresaberService.lookupPlayers(pageNumber);
+        if (page === undefined) {
+          console.log(`Failed to fetch players on page ${pageNumber}, skipping page...`);
+          await delay(cooldown);
+          continue;
+        }
+        for (const player of page.players) {
+          const foundPlayer = await PlayerService.getPlayer(player.id, true, player);
+          await PlayerService.trackScoreSaberPlayer(foundPlayer, player);
+          toRemoveIds.push(foundPlayer.id);
+        }
+        await delay(cooldown);
+      }
+      console.log(`Finished tracking player statistics for ${pages} pages, found ${toRemoveIds.length} players.`);
+
+      // remove all players that have been tracked
+      toTrack = toTrack.filter(player => !toRemoveIds.includes(player.id));
+
+      console.log(`Tracking ${toTrack.length} player statistics...`);
+      for (const player of toTrack) {
+        await PlayerService.trackScoreSaberPlayer(player);
+        await delay(cooldown);
+      }
+      console.log("Finished tracking player statistics.");
+    },
+  })
+);
+
+app.use(
+  cron({
+    name: "scores-background-refresh",
+    pattern: "*/1 * * * *",
+    protect: true,
+    run: async () => {
+      console.log(`Refreshing player score data...`);
+      const players = await PlayerModel.find({});
+      console.log(`Found ${players.length} players to refresh.`);
+
+      for (const player of players) {
+        console.log(`Refreshing scores for ${player.id}...`);
+        let page = 1;
+        let hasMorePages = true;
+
+        while (hasMorePages) {
+          const scoresPage = await scoresaberService.lookupPlayerScores({
+            playerId: player.id,
+            page: page,
+            limit: 100,
+            sort: ScoreSort.recent,
+          });
+          if (!scoresPage) {
+            break;
+          }
+          if (scoresPage.metadata.total <= page * 100) {
+            hasMorePages = false;
+          }
+          page++;
+
+          for (const score of scoresPage.playerScores) {
+            await ScoreService.trackScoreSaberScore(score.score, score.leaderboard, player.id);
+          }
+        }
+        console.log(`Finished refreshing scores for ${player.id}, total pages refreshed: ${page - 1}.`);
+      }
+    },
+  })
+);
+
+/**
+ * Custom error handler
+ */
+app.onError({ as: "global" }, ({ code, error }) => {
+  // Return default error for type validation
+  if (code === "VALIDATION") {
+    return error.all;
+  }
+
+  const status = "status" in error ? error.status : undefined;
+  return {
+    ...((status && { statusCode: status }) || { status: code }),
+    ...(error.message != code && { message: error.message }),
+    timestamp: new Date().toISOString(),
+  };
+});
+
+/**
+ * Enable E-Tags
+ */
+app.use(etag());
+
+/**
+ * Enable CORS
+ */
+app.use(cors());
+
+/**
+ * Request logger
+ */
+app.use(
+  logger({
+    enabled: true,
+    mode: "combined",
+  })
+);
+
+/**
+ * Security settings
+ */
+app.use(
+  helmet({
+    hsts: false, // Disable HSTS
+    contentSecurityPolicy: false, // Disable CSP
+    dnsPrefetchControl: true, // Enable DNS prefetch
+  })
+);
+
+/**
+ * Controllers
+ */
+app.use(
+  decorators({
+    controllers: [AppController, PlayerController, ImageController, ScoresController, LeaderboardController],
+  })
+);
+
+/**
+ * Swagger Documentation
+ */
+app.use(
+  swagger({
+    documentation: {
+      info: {
+        title: "ScoreSaber Reloaded Documentation",
+        version: await getAppVersion(),
+      },
+    },
+    scalarConfig: {
+      servers: [
+        {
+          url: "https://ssr.fascinated.cc/api",
+          description: "Production server",
+        },
+      ],
+    },
+  })
+);
+
+app.onStart(() => {
+  console.log("Listening on port http://localhost:8080");
+  if (isProduction()) {
+    initDiscordBot();
+  }
+});
+
+app.listen(8080);

projects/backend/src/service/app.service.ts

@@ -0,0 +1,24 @@
+import { PlayerModel } from "@ssr/common/model/player";
+import { AppStatistics } from "@ssr/common/types/backend/app-statistics";
+import { ScoreSaberScoreModel } from "@ssr/common/model/score/impl/scoresaber-score";
+import { AdditionalScoreDataModel } from "@ssr/common/model/additional-score-data/additional-score-data";
+import { BeatSaverMapModel } from "@ssr/common/model/beatsaver/map";
+
+export class AppService {
+  /**
+   * Gets the app statistics.
+   */
+  public static async getAppStatistics(): Promise<AppStatistics> {
+    const trackedPlayers = await PlayerModel.countDocuments();
+    const trackedScores = await ScoreSaberScoreModel.countDocuments();
+    const additionalScoresData = await AdditionalScoreDataModel.countDocuments();
+    const cachedBeatSaverMaps = await BeatSaverMapModel.countDocuments();
+
+    return {
+      trackedPlayers,
+      trackedScores,
+      additionalScoresData,
+      cachedBeatSaverMaps,
+    };
+  }
+}

projects/backend/src/service/beatsaver.service.ts

@@ -0,0 +1,98 @@
+import { beatsaverService } from "@ssr/common/service/impl/beatsaver";
+import { BeatSaverMap, BeatSaverMapModel } from "@ssr/common/model/beatsaver/map";
+
+export default class BeatSaverService {
+  /**
+   * Gets a map by its hash, updates if necessary, or inserts if not found.
+   *
+   * @param hash the hash of the map
+   * @returns the beatsaver map, or undefined if not found
+   */
+  public static async getMap(hash: string): Promise<BeatSaverMap | undefined> {
+    let map = await BeatSaverMapModel.findOne({
+      "versions.hash": hash.toUpperCase(),
+    });
+
+    if (map) {
+      const toObject = map.toObject() as BeatSaverMap;
+
+      // If the map is not found, return undefined
+      if (toObject.notFound) {
+        return undefined;
+      }
+
+      // If the map does not need to be refreshed, return it
+      if (!(map as unknown as BeatSaverMap).shouldRefresh()) {
+        return toObject;
+      }
+    }
+
+    // Map needs to be fetched or refreshed
+    const token = await beatsaverService.lookupMap(hash);
+    const uploader = token?.uploader;
+    const metadata = token?.metadata;
+
+    // Create the new map object based on fetched data
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    const newMapData: BeatSaverMap =
+      token && uploader && metadata
+        ? {
+            _id: hash, // todo: change this to an incrementing id
+            bsr: token.id,
+            name: token.name,
+            description: token.description,
+            author: {
+              id: uploader.id,
+              name: uploader.name,
+              avatar: uploader.avatar,
+            },
+            metadata: {
+              bpm: metadata.bpm,
+              duration: metadata.duration,
+              levelAuthorName: metadata.levelAuthorName,
+              songAuthorName: metadata.songAuthorName,
+              songName: metadata.songName,
+              songSubName: metadata.songSubName,
+            },
+            versions: token.versions.map(version => ({
+              hash: version.hash.toUpperCase(),
+              difficulties: version.diffs.map(diff => ({
+                njs: diff.njs,
+                offset: diff.offset,
+                notes: diff.notes,
+                bombs: diff.bombs,
+                obstacles: diff.obstacles,
+                nps: diff.nps,
+                characteristic: diff.characteristic,
+                difficulty: diff.difficulty,
+                events: diff.events,
+                chroma: diff.chroma,
+                mappingExtensions: diff.me,
+                noodleExtensions: diff.ne,
+                cinema: diff.cinema,
+                maxScore: diff.maxScore,
+                label: diff.label,
+              })),
+              createdAt: new Date(version.createdAt),
+            })),
+            lastRefreshed: new Date(),
+          }
+        : {
+            _id: hash,
+            notFound: true,
+          };
+
+    // Upsert the map: if it exists, update it; if not, create a new one
+    map = await BeatSaverMapModel.findOneAndUpdate({ _id: hash }, newMapData, {
+      upsert: true,
+      new: true,
+      setDefaultsOnInsert: true,
+    });
+
+    if (map == null || map.notFound) {
+      return undefined;
+    }
+    return map.toObject() as BeatSaverMap;
+  }
+}

projects/backend/src/service/image.service.tsx

@@ -0,0 +1,221 @@
+import { ImageResponse } from "@vercel/og";
+import { scoresaberService } from "@ssr/common/service/impl/scoresaber";
+import React from "react";
+import { formatNumberWithCommas, formatPp } from "@ssr/common/utils/number-utils";
+import { getDifficultyFromScoreSaberDifficulty } from "@ssr/common/utils/scoresaber-utils";
+import { StarIcon } from "../../components/star-icon";
+import { GlobeIcon } from "../../components/globe-icon";
+import ScoreSaberLeaderboardToken from "@ssr/common/types/token/scoresaber/score-saber-leaderboard-token";
+import ScoreSaberPlayer from "@ssr/common/player/impl/scoresaber-player";
+import { Jimp } from "jimp";
+import { extractColors } from "extract-colors";
+import { Config } from "@ssr/common/config";
+import { fetchWithCache } from "../common/cache.util";
+import { SSRCache } from "@ssr/common/cache";
+import { getScoreSaberPlayerFromToken } from "@ssr/common/token-creators";
+
+const cache = new SSRCache({
+  ttl: 1000 * 60 * 60, // 1 hour
+});
+const imageOptions = { width: 1200, height: 630 };
+
+export class ImageService {
+  /**
+   * Gets the average color of an image
+   *
+   * @param src the image url
+   * @returns the average color
+   * @private
+   */
+  public static async getAverageImageColor(src: string): Promise<{ color: string } | undefined> {
+    src = decodeURIComponent(src);
+
+    return await fetchWithCache<{ color: string }>(cache, `average_color-${src}`, async () => {
+      try {
+        const image = await Jimp.read(src); // Load image using Jimp
+        const { width, height, data } = image.bitmap; // Access image dimensions and pixel data
+
+        // Convert the Buffer data to Uint8ClampedArray
+        const uint8ClampedArray = new Uint8ClampedArray(data);
+
+        // Extract the colors using extract-colors
+        const colors = await extractColors({ data: uint8ClampedArray, width, height });
+
+        // Return the most dominant color, or fallback if none found
+        if (colors && colors.length > 0) {
+          return { color: colors[2].hex }; // Returning the third most dominant color
+        }
+
+        return {
+          color: "#fff", // Fallback color in case no colors are found
+        };
+      } catch (error) {
+        console.error("Error fetching image or extracting colors:", error);
+        return {
+          color: "#fff", // Fallback color in case of an error
+        };
+      }
+    });
+  }
+
+  /**
+   * The base of the OpenGraph image
+   *
+   * @param children the content of the image
+   */
+  public static BaseImage({ children }: { children: React.ReactNode }) {
+    return (
+      <div
+        tw="w-full h-full flex flex-col text-white text-3xl p-3 justify-center items-center relative"
+        style={{
+          backgroundColor: "#0a0a0a",
+          background: "radial-gradient(ellipse 60% 60% at 50% -20%, rgba(120,119,198,0.15), rgba(255,255,255,0))",
+        }}
+      >
+        {children}
+      </div>
+    );
+  }
+
+  /**
+   * Renders the change for a stat.
+   *
+   * @param change the amount of change
+   * @param format the function to format the value
+   */
+  private static renderDailyChange(change: number, format: (value: number) => string = formatNumberWithCommas) {
+    if (change === 0) {
+      return null;
+    }
+
+    return (
+      <p tw={`text-[23px] pl-1 m-0 ${change > 0 ? "text-green-400" : "text-red-400"}`}>
+        {change > 0 ? "+" : ""}
+        {format(change)}
+      </p>
+    );
+  }
+
+  /**
+   * Generates the OpenGraph image for the player
+   *
+   * @param id the player's id
+   */
+  public static async generatePlayerImage(id: string) {
+    const player = await fetchWithCache<ScoreSaberPlayer>(cache, `player-${id}`, async () => {
+      const token = await scoresaberService.lookupPlayer(id);
+      return token ? await getScoreSaberPlayerFromToken(token, Config.apiUrl) : undefined;
+    });
+    if (!player) {
+      return undefined;
+    }
+
+    const { statisticChange } = player;
+    const { daily } = statisticChange ?? {};
+    const rankChange = daily?.countryRank ?? 0;
+    const countryRankChange = daily?.rank ?? 0;
+    const ppChange = daily?.pp ?? 0;
+
+    return new ImageResponse(
+      (
+        <ImageService.BaseImage>
+          {/* Player Avatar */}
+          <img src={player.avatar} width={256} height={256} alt="Player's Avatar" tw="rounded-full mb-3" />
+
+          {/* Player Stats */}
+          <div tw="flex flex-col pl-3 items-center">
+            {/* Player Name */}
+            <p tw="font-bold text-6xl m-0">{player.name}</p>
+
+            {/* Player PP */}
+            <div tw="flex justify-center items-center text-[33px]">
+              <p tw="text-[#4858ff] m-0">{formatPp(player.pp)}pp</p>
+              {this.renderDailyChange(ppChange)}
+            </div>
+
+            {/* Player Stats */}
+            <div tw="flex">
+              {/* Player Rank */}
+              <div tw="flex px-2 justify-center items-center">
+                <GlobeIcon />
+                <p tw="m-0">#{formatNumberWithCommas(player.rank)}</p>
+                {this.renderDailyChange(rankChange)}
+              </div>
+
+              {/* Player Country Rank */}
+              <div tw="flex px-2 justify-center items-center">
+                <img
+                  src={`https://ssr.fascinated.cc/assets/flags/${player.country.toLowerCase()}.png`}
+                  height={20}
+                  alt="Player's Country"
+                />
+                <p tw="pl-1 m-0">#{formatNumberWithCommas(player.countryRank)}</p>
+                {this.renderDailyChange(countryRankChange)}
+              </div>
+            </div>
+
+            {/* Joined Date */}
+            <p tw="m-0 text-gray-400 mt-2">
+              Joined ScoreSaber in{" "}
+              {player.joinedDate.toLocaleString("en-US", {
+                timeZone: "Europe/London",
+                month: "long",
+                year: "numeric",
+              })}
+            </p>
+          </div>
+        </ImageService.BaseImage>
+      ),
+      imageOptions
+    );
+  }
+
+  /**
+   * Generates the OpenGraph image for the leaderboard
+   *
+   * @param id the leaderboard's id
+   */
+  public static async generateLeaderboardImage(id: string) {
+    const leaderboard = await fetchWithCache<ScoreSaberLeaderboardToken>(cache, `leaderboard-${id}`, () =>
+      scoresaberService.lookupLeaderboard(id)
+    );
+    if (!leaderboard) {
+      return undefined;
+    }
+
+    const ranked = leaderboard.stars > 0;
+
+    return new ImageResponse(
+      (
+        <ImageService.BaseImage>
+          {/* Leaderboard Cover Image */}
+          <img src={leaderboard.coverImage} width={256} height={256} alt="Leaderboard Cover" tw="rounded-full mb-3" />
+
+          {/* Leaderboard Name */}
+          <p tw="font-bold text-6xl m-0">
+            {leaderboard.songName} {leaderboard.songSubName}
+          </p>
+
+          <div tw="flex justify-center items-center text-center">
+            {/* Leaderboard Stars */}
+            {ranked && (
+              <div tw="flex justify-center items-center text-4xl">
+                <p tw="font-bold m-0">{leaderboard.stars}</p>
+                <StarIcon />
+              </div>
+            )}
+
+            {/* Leaderboard Difficulty */}
+            <p tw={"font-bold m-0 text-4xl" + (ranked ? " pl-3" : "")}>
+              {getDifficultyFromScoreSaberDifficulty(leaderboard.difficulty.difficulty)}
+            </p>
+          </div>
+
+          {/* Leaderboard Author */}
+          <p tw="font-bold text-2xl text-gray-400 m-0 mt-2">Mapped by {leaderboard.levelAuthorName}</p>
+        </ImageService.BaseImage>
+      ),
+      imageOptions
+    );
+  }
+}

projects/backend/src/service/leaderboard.service.ts

@@ -0,0 +1,75 @@
+import { Leaderboards } from "@ssr/common/leaderboard";
+import { scoresaberService } from "@ssr/common/service/impl/scoresaber";
+import { SSRCache } from "@ssr/common/cache";
+import { LeaderboardResponse } from "@ssr/common/response/leaderboard-response";
+import Leaderboard from "@ssr/common/leaderboard/leaderboard";
+import ScoreSaberLeaderboardToken from "@ssr/common/types/token/scoresaber/score-saber-leaderboard-token";
+import { NotFoundError } from "elysia";
+import BeatSaverService from "./beatsaver.service";
+import { BeatSaverMap } from "@ssr/common/model/beatsaver/map";
+import { getScoreSaberLeaderboardFromToken } from "@ssr/common/token-creators";
+
+const leaderboardCache = new SSRCache({
+  ttl: 1000 * 60 * 60 * 24,
+});
+
+export default class LeaderboardService {
+  /**
+   * Gets the leaderboard.
+   *
+   * @param leaderboard the leaderboard
+   * @param id the id
+   */
+  private static async getLeaderboardToken<T>(leaderboard: Leaderboards, id: string): Promise<T | undefined> {
+    const cacheKey = `${leaderboard}-${id}`;
+    if (leaderboardCache.has(cacheKey)) {
+      return leaderboardCache.get(cacheKey) as T;
+    }
+
+    switch (leaderboard) {
+      case "scoresaber": {
+        const leaderboard = (await scoresaberService.lookupLeaderboard(id)) as T;
+        leaderboardCache.set(cacheKey, leaderboard);
+        return leaderboard;
+      }
+      default: {
+        return undefined;
+      }
+    }
+  }
+
+  /**
+   * Gets a leaderboard.
+   *
+   * @param leaderboardName the leaderboard to get
+   * @param id the players id
+   * @returns the scores
+   */
+  public static async getLeaderboard<L>(leaderboardName: Leaderboards, id: string): Promise<LeaderboardResponse<L>> {
+    let leaderboard: Leaderboard | undefined;
+    let beatSaverMap: BeatSaverMap | undefined;
+
+    switch (leaderboardName) {
+      case "scoresaber": {
+        const leaderboardToken = await LeaderboardService.getLeaderboardToken<ScoreSaberLeaderboardToken>(
+          leaderboardName,
+          id
+        );
+        if (leaderboardToken == undefined) {
+          throw new NotFoundError(`Leaderboard not found for "${id}"`);
+        }
+        leaderboard = getScoreSaberLeaderboardFromToken(leaderboardToken);
+        beatSaverMap = await BeatSaverService.getMap(leaderboard.songHash);
+        break;
+      }
+      default: {
+        throw new NotFoundError(`Leaderboard "${leaderboardName}" not found`);
+      }
+    }
+
+    return {
+      leaderboard: leaderboard as L,
+      beatsaver: beatSaverMap,
+    };
+  }
+}

projects/backend/src/service/player.service.ts

@@ -0,0 +1,246 @@
+import { PlayerDocument, PlayerModel } from "@ssr/common/model/player";
+import { NotFoundError } from "../error/not-found-error";
+import { getDaysAgoDate, getMidnightAlignedDate } from "@ssr/common/utils/time-utils";
+import { scoresaberService } from "@ssr/common/service/impl/scoresaber";
+import ScoreSaberPlayerToken from "@ssr/common/types/token/scoresaber/score-saber-player-token";
+import { InternalServerError } from "../error/internal-server-error";
+import { formatPp } from "@ssr/common/utils/number-utils";
+import { getPageFromRank, isProduction } from "@ssr/common/utils/utils";
+import { DiscordChannels, logToChannel } from "../bot/bot";
+import { EmbedBuilder } from "discord.js";
+import { AroundPlayer } from "@ssr/common/types/around-player";
+
+export class PlayerService {
+  /**
+   * Get a player from the database.
+   *
+   * @param id the player to fetch
+   * @param create if true, create the player if it doesn't exist
+   * @param playerToken an optional player token for the player
+   * @returns the player
+   * @throws NotFoundError if the player is not found
+   */
+  public static async getPlayer(
+    id: string,
+    create: boolean = false,
+    playerToken?: ScoreSaberPlayerToken
+  ): Promise<PlayerDocument> {
+    let player: PlayerDocument | null = await PlayerModel.findById(id);
+    if (player === null) {
+      // If create is on, create the player, otherwise return unknown player
+      playerToken = create ? (playerToken ? playerToken : await scoresaberService.lookupPlayer(id)) : undefined;
+      if (playerToken === undefined) {
+        throw new NotFoundError(`Player "${id}" not found`);
+      }
+
+      console.log(`Creating player "${id}"...`);
+      try {
+        player = (await PlayerModel.create({ _id: id })) as PlayerDocument;
+        player.trackedSince = new Date();
+        await this.seedPlayerHistory(player, playerToken);
+
+        // Only notify in production
+        if (isProduction()) {
+          await logToChannel(
+            DiscordChannels.trackedPlayerLogs,
+            new EmbedBuilder()
+              .setTitle("New Player Tracked")
+              .setDescription(`https://ssr.fascinated.cc/player/${playerToken.id}`)
+              .addFields([
+                {
+                  name: "Username",
+                  value: playerToken.name,
+                  inline: true,
+                },
+                {
+                  name: "ID",
+                  value: playerToken.id,
+                  inline: true,
+                },
+                {
+                  name: "PP",
+                  value: formatPp(playerToken.pp) + "pp",
+                  inline: true,
+                },
+              ])
+              .setThumbnail(playerToken.profilePicture)
+              .setColor("#00ff00")
+          );
+        }
+      } catch (err) {
+        const message = `Failed to create player document for "${id}"`;
+        console.log(message, err);
+        throw new InternalServerError(message);
+      }
+    }
+    return player;
+  }
+
+  /**
+   * Seeds the player's history using data from
+   * the ScoreSaber API.
+   *
+   * @param player the player to seed
+   * @param playerToken the SoreSaber player token
+   */
+  public static async seedPlayerHistory(player: PlayerDocument, playerToken: ScoreSaberPlayerToken): Promise<void> {
+    // Loop through rankHistory in reverse, from current day backwards
+    const playerRankHistory = playerToken.histories.split(",").map((value: string) => {
+      return parseInt(value);
+    });
+    playerRankHistory.push(playerToken.rank);
+
+    let daysAgo = 1; // Start from yesterday
+    for (let i = playerRankHistory.length - daysAgo - 1; i >= 0; i--) {
+      const rank = playerRankHistory[i];
+      // Skip inactive days
+      if (rank == 999_999) {
+        continue;
+      }
+
+      const date = getMidnightAlignedDate(getDaysAgoDate(daysAgo));
+      player.setStatisticHistory(date, {
+        rank: rank,
+      });
+      daysAgo += 1; // Increment daysAgo for each earlier rank
+    }
+    player.markModified("statisticHistory");
+    await player.save();
+  }
+
+  /**
+   * Tracks a players statistics
+   *
+   * @param foundPlayer the player to track
+   * @param playerToken an optional player token
+   */
+  public static async trackScoreSaberPlayer(
+    foundPlayer: PlayerDocument,
+    playerToken?: ScoreSaberPlayerToken
+  ): Promise<void> {
+    const dateToday = getMidnightAlignedDate(new Date());
+    const player = playerToken ? playerToken : await scoresaberService.lookupPlayer(foundPlayer.id);
+    if (player == undefined) {
+      console.log(`Player "${foundPlayer.id}" not found on ScoreSaber`);
+      return;
+    }
+    if (player.inactive) {
+      console.log(`Player "${foundPlayer.id}" is inactive on ScoreSaber`);
+      return;
+    }
+
+    // Seed the history with ScoreSaber data if no history exists
+    if (foundPlayer.getDaysTracked() === 0) {
+      await this.seedPlayerHistory(foundPlayer, player);
+    }
+
+    // Update current day's statistics
+    let history = foundPlayer.getHistoryByDate(dateToday);
+    if (history == undefined) {
+      history = {}; // Initialize if history is not found
+    }
+
+    const scoreStats = player.scoreStats;
+
+    // Set the history data
+    history.pp = player.pp;
+    history.countryRank = player.countryRank;
+    history.rank = player.rank;
+    history.accuracy = {
+      ...history.accuracy,
+      averageRankedAccuracy: scoreStats.averageRankedAccuracy,
+    };
+    history.scores = {
+      rankedScores: 0,
+      unrankedScores: 0,
+      ...history.scores,
+      totalScores: scoreStats.totalPlayCount,
+      totalRankedScores: scoreStats.rankedPlayCount,
+    };
+    history.score = {
+      ...history.score,
+      totalScore: scoreStats.totalScore,
+      totalRankedScore: scoreStats.totalRankedScore,
+    };
+
+    foundPlayer.setStatisticHistory(dateToday, history);
+    foundPlayer.sortStatisticHistory();
+    foundPlayer.lastTracked = new Date();
+    foundPlayer.markModified("statisticHistory");
+    await foundPlayer.save();
+
+    console.log(`Tracked player "${foundPlayer.id}"!`);
+  }
+
+  /**
+   * Gets the players around a player.
+   *
+   * @param id the player to get around
+   * @param type the type to get around
+   */
+  public static async getPlayersAroundPlayer(id: string, type: AroundPlayer): Promise<ScoreSaberPlayerToken[]> {
+    const getRank = (player: ScoreSaberPlayerToken, type: AroundPlayer) => {
+      switch (type) {
+        case "global":
+          return player.rank;
+        case "country":
+          return player.countryRank;
+      }
+    };
+
+    const itemsPerPage = 50;
+    const player = await scoresaberService.lookupPlayer(id);
+    if (player == undefined) {
+      throw new NotFoundError(`Player "${id}" not found`);
+    }
+    const rank = getRank(player, type);
+    const rankWithinPage = rank % itemsPerPage;
+
+    const pagesToSearch = [getPageFromRank(rank, itemsPerPage)];
+    if (rankWithinPage > 0) {
+      pagesToSearch.push(getPageFromRank(rank - 1, itemsPerPage));
+    } else if (rankWithinPage < itemsPerPage - 1) {
+      pagesToSearch.push(getPageFromRank(rank + 1, itemsPerPage));
+    }
+
+    const rankings: Map<string, ScoreSaberPlayerToken> = new Map();
+    for (const page of pagesToSearch) {
+      const response =
+        type == "global"
+          ? await scoresaberService.lookupPlayers(page)
+          : await scoresaberService.lookupPlayersByCountry(page, player.country);
+      if (response == undefined) {
+        continue;
+      }
+
+      for (const player of response.players) {
+        if (rankings.has(player.id)) {
+          continue;
+        }
+
+        rankings.set(player.id, player);
+      }
+    }
+
+    const players = rankings
+      .values()
+      .toArray()
+      .sort((a, b) => {
+        return getRank(a, type) - getRank(b, type);
+      });
+
+    // Show 3 players above and 1 below the requested player
+    const playerPosition = players.findIndex(p => p.id === player.id);
+    const start = Math.max(0, playerPosition - 3);
+    let end = Math.min(players.length, playerPosition + 2);
+
+    const playersLength = players.slice(start, end).length;
+
+    // If there is less than 5 players to return, add more players to the end
+    if (playersLength < 5) {
+      end = Math.min(end + 5 - playersLength, players.length);
+    }
+
+    return players.slice(start, end);
+  }
+}

projects/backend/src/service/score.service.ts

@@ -0,0 +1,534 @@
+import ScoreSaberPlayerScoreToken from "@ssr/common/types/token/scoresaber/score-saber-player-score-token";
+import { formatNumberWithCommas, formatPp } from "@ssr/common/utils/number-utils";
+import { isProduction } from "@ssr/common/utils/utils";
+import { Metadata } from "@ssr/common/types/metadata";
+import { NotFoundError } from "elysia";
+import { scoresaberService } from "@ssr/common/service/impl/scoresaber";
+import { Leaderboards } from "@ssr/common/leaderboard";
+import Leaderboard from "@ssr/common/leaderboard/leaderboard";
+import LeaderboardService from "./leaderboard.service";
+import { BeatSaverMap } from "@ssr/common/model/beatsaver/map";
+import { PlayerScore } from "@ssr/common/score/player-score";
+import LeaderboardScoresResponse from "@ssr/common/response/leaderboard-scores-response";
+import PlayerScoresResponse from "@ssr/common/response/player-scores-response";
+import { DiscordChannels, logToChannel } from "../bot/bot";
+import { EmbedBuilder } from "discord.js";
+import { Config } from "@ssr/common/config";
+import { SSRCache } from "@ssr/common/cache";
+import { fetchWithCache } from "../common/cache.util";
+import { PlayerDocument, PlayerModel } from "@ssr/common/model/player";
+import { BeatLeaderScoreToken } from "@ssr/common/types/token/beatleader/score/score";
+import {
+  AdditionalScoreData,
+  AdditionalScoreDataModel,
+} from "@ssr/common/model/additional-score-data/additional-score-data";
+import { BeatLeaderScoreImprovementToken } from "@ssr/common/types/token/beatleader/score/score-improvement";
+import Score, { ScoreType } from "@ssr/common/model/score/score";
+import { getScoreSaberLeaderboardFromToken, getScoreSaberScoreFromToken } from "@ssr/common/token-creators";
+import {
+  ScoreSaberScore,
+  ScoreSaberScoreInternal,
+  ScoreSaberScoreModel,
+} from "@ssr/common/model/score/impl/scoresaber-score";
+import ScoreSaberLeaderboard from "@ssr/common/leaderboard/impl/scoresaber-leaderboard";
+import { ScoreSorters } from "@ssr/common/sorter/sorters";
+import { ScoreSortType } from "@ssr/common/sorter/sort-type";
+import { SortDirection } from "@ssr/common/sorter/sort-direction";
+import { Pagination } from "../../../common/src/pagination";
+import { PlayerService } from "./player.service";
+import { ScoreSort } from "@ssr/common/score/score-sort";
+import BeatSaverService from "./beatsaver.service";
+import ScoreSaberPlayerToken from "@ssr/common/types/token/scoresaber/score-saber-player-token";
+import ScoreSaberScoreToken from "@ssr/common/types/token/scoresaber/score-saber-score-token";
+import ScoreSaberLeaderboardToken from "@ssr/common/types/token/scoresaber/score-saber-leaderboard-token";
+
+const playerScoresCache = new SSRCache({
+  ttl: 1000 * 60, // 1 minute
+});
+
+const leaderboardScoresCache = new SSRCache({
+  ttl: 1000 * 60, // 1 minute
+});
+
+const ITEMS_PER_PAGE = 8;
+
+export class ScoreService {
+  /**
+   * Notifies the number one score in Discord.
+   *
+   * @param playerScore the score to notify
+   */
+  public static async notifyNumberOne(playerScore: ScoreSaberPlayerScoreToken) {
+    // Only notify in production
+    if (!isProduction()) {
+      return;
+    }
+
+    const { score: scoreToken, leaderboard: leaderboardToken } = playerScore;
+    const leaderboard = getScoreSaberLeaderboardFromToken(leaderboardToken);
+    const score = getScoreSaberScoreFromToken(scoreToken, leaderboard, scoreToken.leaderboardPlayerInfo.id);
+    const playerInfo = score.playerInfo;
+
+    // Not ranked
+    if (leaderboard.stars <= 0) {
+      return;
+    }
+    // Not #1 rank
+    if (score.rank !== 1) {
+      return;
+    }
+
+    const player = await scoresaberService.lookupPlayer(playerInfo.id);
+    if (!player) {
+      return;
+    }
+
+    await logToChannel(
+      DiscordChannels.numberOneFeed,
+      new EmbedBuilder()
+        .setTitle(`${player.name} just set a #1!`)
+        .setDescription(
+          [
+            `${leaderboard.songName} ${leaderboard.songSubName} (${leaderboard.difficulty.difficulty} ${leaderboard.stars.toFixed(2)}★)`,
+            `[[Player]](${Config.websiteUrl}/player/${player.id}) [[Leaderboard]](${Config.websiteUrl}/leaderboard/${leaderboard.id})`,
+          ].join("\n")
+        )
+        .addFields([
+          {
+            name: "Accuracy",
+            value: `${score.accuracy.toFixed(2)}%`,
+            inline: true,
+          },
+          {
+            name: "PP",
+            value: `${formatPp(score.pp)}pp`,
+            inline: true,
+          },
+          {
+            name: "Player Rank",
+            value: `#${formatNumberWithCommas(player.rank)}`,
+            inline: true,
+          },
+          {
+            name: "Misses",
+            value: formatNumberWithCommas(score.missedNotes),
+            inline: true,
+          },
+          {
+            name: "Bad Cuts",
+            value: formatNumberWithCommas(score.badCuts),
+            inline: true,
+          },
+          {
+            name: "Max Combo",
+            value: formatNumberWithCommas(score.maxCombo),
+            inline: true,
+          },
+        ])
+        .setThumbnail(leaderboard.songArt)
+        .setTimestamp(score.timestamp)
+        .setColor("#00ff00")
+    );
+  }
+
+  /**
+   * Updates the players set scores count for today.
+   *
+   * @param score the score
+   */
+  public static async updatePlayerScoresSet({
+    score: scoreToken,
+    leaderboard: leaderboardToken,
+  }: ScoreSaberPlayerScoreToken) {
+    const playerId = scoreToken.leaderboardPlayerInfo.id;
+
+    const leaderboard = getScoreSaberLeaderboardFromToken(leaderboardToken);
+    const player: PlayerDocument | null = await PlayerModel.findById(playerId);
+    // Player is not tracked, so ignore the score.
+    if (player == undefined) {
+      return;
+    }
+
+    const today = new Date();
+    const history = player.getHistoryByDate(today);
+    const scores = history.scores || {
+      rankedScores: 0,
+      unrankedScores: 0,
+    };
+    if (leaderboard.stars > 0) {
+      scores.rankedScores!++;
+    } else {
+      scores.unrankedScores!++;
+    }
+
+    history.scores = scores;
+    player.setStatisticHistory(today, history);
+    await player.save();
+  }
+
+  /**
+   * Tracks ScoreSaber score.
+   *
+   * @param scoreToken the score to track
+   * @param leaderboardToken the leaderboard for the score
+   * @param playerId the id of the player
+   */
+  public static async trackScoreSaberScore(
+    scoreToken: ScoreSaberScoreToken,
+    leaderboardToken: ScoreSaberLeaderboardToken,
+    playerId?: string
+  ) {
+    playerId = playerId || scoreToken.leaderboardPlayerInfo.id;
+
+    const leaderboard = getScoreSaberLeaderboardFromToken(leaderboardToken);
+    const score = getScoreSaberScoreFromToken(scoreToken, leaderboard, playerId);
+    const player: PlayerDocument | null = await PlayerModel.findById(playerId);
+    // Player is not tracked, so ignore the score.
+    if (player == undefined) {
+      return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    delete score.playerInfo;
+
+    await ScoreSaberScoreModel.create(score);
+  }
+
+  /**
+   * Tracks BeatLeader score.
+   *
+   * @param score the score to track
+   */
+  public static async trackBeatLeaderScore(score: BeatLeaderScoreToken) {
+    const { playerId, player: scorePlayer, leaderboard } = score;
+    const player: PlayerDocument | null = await PlayerModel.findById(playerId);
+    // Player is not tracked, so ignore the score.
+    if (player == undefined) {
+      return;
+    }
+
+    // The score has already been tracked, so ignore it.
+    if (
+      (await this.getAdditionalScoreData(
+        playerId,
+        leaderboard.song.hash,
+        leaderboard.difficulty.difficultyName,
+        score.baseScore
+      )) !== undefined
+    ) {
+      return;
+    }
+
+    const getMisses = (score: BeatLeaderScoreToken | BeatLeaderScoreImprovementToken) => {
+      return score.missedNotes + score.badCuts + score.bombCuts;
+    };
+
+    const difficulty = leaderboard.difficulty;
+    const difficultyKey = `${difficulty.difficultyName}-${difficulty.modeName}`;
+    const rawScoreImprovement = score.scoreImprovement;
+    const data = {
+      playerId: playerId,
+      songHash: leaderboard.song.hash.toUpperCase(),
+      songDifficulty: difficultyKey,
+      songScore: score.baseScore,
+      scoreId: score.id,
+      leaderboardId: leaderboard.id,
+      misses: {
+        misses: getMisses(score),
+        missedNotes: score.missedNotes,
+        bombCuts: score.bombCuts,
+        badCuts: score.badCuts,
+        wallsHit: score.wallsHit,
+      },
+      pauses: score.pauses,
+      fcAccuracy: score.fcAccuracy * 100,
+      fullCombo: score.fullCombo,
+      handAccuracy: {
+        left: score.accLeft,
+        right: score.accRight,
+      },
+      timestamp: new Date(Number(score.timeset) * 1000),
+    } as AdditionalScoreData;
+    if (rawScoreImprovement && rawScoreImprovement.score > 0) {
+      data.scoreImprovement = {
+        score: rawScoreImprovement.score,
+        misses: {
+          misses: getMisses(rawScoreImprovement),
+          missedNotes: rawScoreImprovement.missedNotes,
+          bombCuts: rawScoreImprovement.bombCuts,
+          badCuts: rawScoreImprovement.badCuts,
+          wallsHit: rawScoreImprovement.wallsHit,
+        },
+        accuracy: rawScoreImprovement.accuracy * 100,
+        handAccuracy: {
+          left: rawScoreImprovement.accLeft,
+          right: rawScoreImprovement.accRight,
+        },
+      };
+    }
+
+    await AdditionalScoreDataModel.create(data);
+    console.log(
+      `Tracked additional score data for "${scorePlayer.name}"(${playerId}), difficulty: ${difficultyKey}, score: ${score.baseScore}`
+    );
+  }
+
+  /**
+   * Gets the additional score data for a player's score.
+   *
+   * @param playerId the id of the player
+   * @param songHash the hash of the map
+   * @param songDifficulty the difficulty of the map
+   * @param songScore the score of the play
+   * @private
+   */
+  private static async getAdditionalScoreData(
+    playerId: string,
+    songHash: string,
+    songDifficulty: string,
+    songScore: number
+  ): Promise<AdditionalScoreData | undefined> {
+    const additionalData = await AdditionalScoreDataModel.findOne({
+      playerId: playerId,
+      songHash: songHash.toUpperCase(),
+      songDifficulty: songDifficulty,
+      songScore: songScore,
+    });
+    if (!additionalData) {
+      return undefined;
+    }
+    return additionalData.toObject();
+  }
+
+  /**
+   * Gets scores for a player.
+   *
+   * @param leaderboardName the leaderboard to get the scores from
+   * @param playerId the players id
+   * @param page the page to get
+   * @param sort the sort type to use
+   * @param direction the direction to sort the scores
+   * @param search the search to use
+   * @returns the scores
+   */
+  public static async getPlayerScores(
+    leaderboardName: Leaderboards,
+    playerId: string,
+    page: number,
+    sort: ScoreSortType,
+    direction: SortDirection,
+    search?: string
+  ): Promise<PlayerScoresResponse<unknown, unknown> | undefined> {
+    console.log(
+      `Fetching scores for ${playerId} on ${leaderboardName}, page: ${page}, sort: ${sort}, direction: ${direction}, search: ${search}`
+    );
+
+    return fetchWithCache(
+      playerScoresCache,
+      `player-scores-${leaderboardName}-${playerId}-${page}-${sort}-${search}`,
+      async () => {
+        const toReturn: PlayerScore<unknown, unknown>[] | undefined = [];
+        let metadata: Metadata = new Metadata(0, 0, 0, 0); // Default values
+
+        switch (leaderboardName) {
+          case "scoresaber": {
+            let isPlayerTracked = false;
+            try {
+              isPlayerTracked = (await PlayerService.getPlayer(playerId, false)) != undefined;
+            } catch {
+              /* ignored */
+            }
+            if (isPlayerTracked) {
+              const rawScores = ScoreSorters.scoreSaber.sort(
+                sort,
+                direction,
+                (await ScoreSaberScoreModel.find({ playerId: playerId }).exec()) as unknown as ScoreSaberScore[]
+              );
+              if (!rawScores || rawScores.length === 0) {
+                break;
+              }
+
+              const pagination = new Pagination<ScoreSaberScore>().setItemsPerPage(ITEMS_PER_PAGE).setItems(rawScores);
+              const paginatedPage = pagination.getPage(page);
+              metadata = paginatedPage.metadata;
+
+              for (const score of paginatedPage.items) {
+                const { leaderboard, beatsaver } = await LeaderboardService.getLeaderboard<ScoreSaberLeaderboard>(
+                  "scoresaber",
+                  String(score.leaderboardId)
+                );
+                if (leaderboard == undefined) {
+                  continue;
+                }
+
+                const additionalData = await this.getAdditionalScoreData(
+                  playerId,
+                  leaderboard.songHash,
+                  `${leaderboard.difficulty.difficulty}-${leaderboard.difficulty.characteristic}`,
+                  score.score
+                );
+                if (additionalData == undefined) {
+                  continue;
+                }
+
+                toReturn.push({
+                  score: score,
+                  leaderboard: leaderboard,
+                  beatSaver: beatsaver,
+                });
+              }
+            } else {
+              // Convert the sort type
+              let scoreSaberSort: ScoreSort;
+              switch (sort) {
+                case ScoreSortType.date: {
+                  scoreSaberSort = ScoreSort.recent;
+                  break;
+                }
+                case ScoreSortType.pp: {
+                  scoreSaberSort = ScoreSort.top;
+                  break;
+                }
+                default: {
+                  scoreSaberSort = ScoreSort.recent;
+                  break;
+                }
+              }
+
+              const rawScores = await scoresaberService.lookupPlayerScores({
+                playerId: playerId,
+                page: page,
+                sort: scoreSaberSort,
+                search: search,
+              });
+              if (!rawScores || rawScores.playerScores.length === 0) {
+                break;
+              }
+
+              metadata = new Metadata(
+                Math.ceil(rawScores.metadata.total / rawScores.metadata.itemsPerPage),
+                rawScores.metadata.total,
+                rawScores.metadata.page,
+                rawScores.metadata.itemsPerPage
+              );
+
+              for (const token of rawScores.playerScores) {
+                const leaderboard = getScoreSaberLeaderboardFromToken(token.leaderboard);
+                if (leaderboard == undefined) {
+                  continue;
+                }
+
+                const score = getScoreSaberScoreFromToken(token.score, leaderboard, playerId);
+                if (score == undefined) {
+                  continue;
+                }
+
+                const additionalData = await this.getAdditionalScoreData(
+                  playerId,
+                  leaderboard.songHash,
+                  `${leaderboard.difficulty.difficulty}-${leaderboard.difficulty.characteristic}`,
+                  score.score
+                );
+                if (additionalData !== undefined) {
+                  score.additionalData = additionalData;
+                }
+
+                toReturn.push({
+                  score: score,
+                  leaderboard: leaderboard,
+                  beatSaver: await BeatSaverService.getMap(leaderboard.songHash),
+                });
+              }
+            }
+
+            break;
+          }
+          default: {
+            throw new NotFoundError(`Leaderboard "${leaderboardName}" not found`);
+          }
+        }
+
+        console.log(metadata);
+        return {
+          scores: toReturn,
+          metadata: metadata,
+        };
+      }
+    );
+  }
+
+  /**
+   * Gets scores for a leaderboard.
+   *
+   * @param leaderboardName the leaderboard to get the scores from
+   * @param leaderboardId the leaderboard id
+   * @param page the page to get
+   * @returns the scores
+   */
+  public static async getLeaderboardScores(
+    leaderboardName: Leaderboards,
+    leaderboardId: string,
+    page: number
+  ): Promise<LeaderboardScoresResponse<unknown, unknown> | undefined> {
+    return fetchWithCache(
+      leaderboardScoresCache,
+      `leaderboard-scores-${leaderboardName}-${leaderboardId}-${page}`,
+      async () => {
+        const scores: ScoreType[] = [];
+        let leaderboard: Leaderboard | undefined;
+        let beatSaverMap: BeatSaverMap | undefined;
+        let metadata: Metadata = new Metadata(0, 0, 0, 0); // Default values
+
+        switch (leaderboardName) {
+          case "scoresaber": {
+            const leaderboardResponse = await LeaderboardService.getLeaderboard<ScoreSaberLeaderboard>(
+              leaderboardName,
+              leaderboardId
+            );
+            if (leaderboardResponse == undefined) {
+              throw new NotFoundError(`Leaderboard "${leaderboardName}" not found`);
+            }
+            leaderboard = leaderboardResponse.leaderboard;
+            beatSaverMap = leaderboardResponse.beatsaver;
+
+            const leaderboardScores = await scoresaberService.lookupLeaderboardScores(leaderboardId, page);
+            if (leaderboardScores == undefined) {
+              break;
+            }
+
+            for (const token of leaderboardScores.scores) {
+              const score = getScoreSaberScoreFromToken(
+                token,
+                leaderboardResponse.leaderboard,
+                token.leaderboardPlayerInfo.id
+              );
+              if (score == undefined) {
+                continue;
+              }
+              scores.push(score);
+            }
+
+            metadata = new Metadata(
+              Math.ceil(leaderboardScores.metadata.total / leaderboardScores.metadata.itemsPerPage),
+              leaderboardScores.metadata.total,
+              leaderboardScores.metadata.page,
+              leaderboardScores.metadata.itemsPerPage
+            );
+            break;
+          }
+          default: {
+            throw new NotFoundError(`Leaderboard "${leaderboardName}" not found`);
+          }
+        }
+
+        return {
+          scores: scores,
+          leaderboard: leaderboard,
+          beatSaver: beatSaverMap,
+          metadata: metadata,
+        };
+      }
+    );
+  }
+}

projects/backend/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "types": ["bun-types"],
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "jsx": "react",
+  },
+}

projects/common/.dockerignore

@@ -0,0 +1,2 @@
+node_modules
+dist

projects/common/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@ssr/common",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "tsc --watch --preserveWatchOutput",
+    "build": "tsc"
+  },
+  "exports": {
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "require": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.4",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@typegoose/auto-increment": "^4.7.0",
+    "@typegoose/typegoose": "^12.8.0",
+    "ky": "^1.7.2",
+    "ws": "^8.18.0"
+  }
+}

projects/common/src/cache.ts

@@ -0,0 +1,129 @@
+type CacheOptions = {
+  /**
+   * The time the cached object will be valid for
+   */
+  ttl?: number;
+
+  /**
+   * How often to check for expired objects
+   */
+  checkInterval?: number;
+
+  /**
+   * Enable debug messages
+   */
+  debug?: boolean;
+};
+
+type CachedObject = {
+  /**
+   * The cached object
+   */
+  value: any;
+
+  /**
+   * The timestamp the object was cached
+   */
+  timestamp: number;
+};
+
+export class SSRCache {
+  /**
+   * The time the cached object will be valid for
+   * @private
+   */
+  private readonly ttl: number | undefined;
+
+  /**
+   * How often to check for expired objects
+   * @private
+   */
+  private readonly checkInterval: number | undefined;
+
+  /**
+   * Enable debug messages
+   * @private
+   */
+  private readonly debug: boolean;
+
+  /**
+   * The objects that have been cached
+   * @private
+   */
+  private cache = new Map<string, CachedObject>();
+
+  constructor({ ttl, checkInterval, debug }: CacheOptions) {
+    this.ttl = ttl;
+    this.checkInterval = checkInterval || this.ttl ? 1000 * 60 : undefined; // 1 minute
+    this.debug = debug || false;
+
+    if (this.ttl !== undefined && this.checkInterval !== undefined) {
+      setInterval(() => {
+        for (const [key, value] of this.cache.entries()) {
+          if (value.timestamp + this.ttl! > Date.now()) {
+            continue;
+          }
+          this.remove(key);
+        }
+      }, this.checkInterval);
+    }
+  }
+
+  /**
+   * Gets an object from the cache
+   *
+   * @param key the cache key for the object
+   */
+  public get<T>(key: string): T | undefined {
+    const cachedObject = this.cache.get(key);
+    if (cachedObject === undefined) {
+      if (this.debug) {
+        console.log(`Cache miss for key: ${key}`);
+      }
+      return undefined;
+    }
+    if (this.debug) {
+      console.log(`Retrieved ${key} from cache, value: ${JSON.stringify(cachedObject)}`);
+    }
+    return cachedObject.value as T;
+  }
+
+  /**
+   * Sets an object in the cache
+   *
+   * @param key the cache key
+   * @param value the object
+   */
+  public set<T>(key: string, value: T): void {
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+    });
+
+    if (this.debug) {
+      console.log(`Inserted ${key} into cache, value: ${JSON.stringify(value)}`);
+    }
+  }
+
+  /**
+   * Checks if an object is in the cache
+   *
+   * @param key the cache key
+   */
+  public has(key: string): boolean {
+    return this.cache.has(key);
+  }
+
+  /**
+   * Removes an object from the cache
+   *
+   * @param key the cache key
+   */
+  public remove(key: string): void {
+    this.cache.delete(key);
+
+    if (this.debug) {
+      console.log(`Removed ${key} from cache`);
+    }
+  }
+}

projects/common/src/config.ts

@@ -0,0 +1,13 @@
+export const Config = {
+  /**
+   * All projects
+   */
+  websiteUrl: process.env.NEXT_PUBLIC_SITE_URL || "https://ssr.fascinated.cc",
+  apiUrl: process.env.NEXT_PUBLIC_SITE_API || "https://ssr.fascinated.cc/api",
+
+  /**
+   * Backend
+   */
+  mongoUri: process.env.MONGO_URI,
+  discordBotToken: process.env.DISCORD_BOT_TOKEN,
+} as const;

projects/common/src/leaderboard.ts

@@ -0,0 +1,5 @@
+const Leaderboards = {
+  SCORESABER: "scoresaber",
+} as const;
+
+export type Leaderboards = (typeof Leaderboards)[keyof typeof Leaderboards];

projects/common/src/leaderboard/impl/scoresaber-leaderboard.ts

@@ -0,0 +1,29 @@
+import Leaderboard from "../leaderboard";
+import { LeaderboardStatus } from "../leaderboard-status";
+
+export default interface ScoreSaberLeaderboard extends Leaderboard {
+  /**
+   * The star count for the leaderboard.
+   */
+  readonly stars: number;
+
+  /**
+   * The total amount of plays.
+   */
+  readonly plays: number;
+
+  /**
+   * The amount of plays today.
+   */
+  readonly dailyPlays: number;
+
+  /**
+   * Whether this leaderboard is qualified to be ranked.
+   */
+  readonly qualified: boolean;
+
+  /**
+   * The status of the map.
+   */
+  readonly status: LeaderboardStatus;
+}

projects/common/src/leaderboard/leaderboard-difficulty.ts

@@ -0,0 +1,24 @@
+import { MapDifficulty } from "../score/map-difficulty";
+import { MapCharacteristic } from "../types/map-characteristic";
+
+export default interface LeaderboardDifficulty {
+  /**
+   * The id of the leaderboard.
+   */
+  leaderboardId: number;
+
+  /**
+   * The difficulty of the leaderboard.
+   */
+  difficulty: MapDifficulty;
+
+  /**
+   * The characteristic of the leaderboard.
+   */
+  characteristic: MapCharacteristic;
+
+  /**
+   * The raw difficulty of the leaderboard.
+   */
+  difficultyRaw: string;
+}

projects/common/src/leaderboard/leaderboard-status.ts

@@ -0,0 +1,4 @@
+/**
+ * The status of the leaderboard.
+ */
+export type LeaderboardStatus = "Unranked" | "Ranked" | "Qualified";

projects/common/src/leaderboard/leaderboard.ts

@@ -0,0 +1,75 @@
+import LeaderboardDifficulty from "./leaderboard-difficulty";
+
+export default interface Leaderboard {
+  /**
+   * The id of the leaderboard.
+   * @private
+   */
+  readonly id: number;
+
+  /**
+   * The hash of the song this leaderboard is for.
+   * @private
+   */
+  readonly songHash: string;
+
+  /**
+   * The name of the song this leaderboard is for.
+   * @private
+   */
+  readonly songName: string;
+
+  /**
+   * The sub name of the leaderboard.
+   * @private
+   */
+  readonly songSubName: string;
+
+  /**
+   * The author of the song this leaderboard is for.
+   * @private
+   */
+  readonly songAuthorName: string;
+
+  /**
+   * The author of the level this leaderboard is for.
+   * @private
+   */
+  readonly levelAuthorName: string;
+
+  /**
+   * The difficulty of the leaderboard.
+   * @private
+   */
+  readonly difficulty: LeaderboardDifficulty;
+
+  /**
+   * The difficulties of the leaderboard.
+   * @private
+   */
+  readonly difficulties: LeaderboardDifficulty[];
+
+  /**
+   * The maximum score of the leaderboard.
+   * @private
+   */
+  readonly maxScore: number;
+
+  /**
+   * Whether the leaderboard is ranked.
+   * @private
+   */
+  readonly ranked: boolean;
+
+  /**
+   * The link to the song art.
+   * @private
+   */
+  readonly songArt: string;
+
+  /**
+   * The date the leaderboard was created.
+   * @private
+   */
+  readonly timestamp: Date;
+}

projects/common/src/model/additional-score-data/additional-score-data.ts

@@ -0,0 +1,133 @@
+import { getModelForClass, modelOptions, prop, ReturnModelType, Severity } from "@typegoose/typegoose";
+import { Document } from "mongoose";
+import { HandAccuracy } from "./hand-accuracy";
+import { Misses } from "./misses";
+
+/**
+ * The model for additional score data.
+ */
+@modelOptions({
+  options: { allowMixed: Severity.ALLOW },
+  schemaOptions: {
+    collection: "additional-score-data",
+    toObject: {
+      virtuals: true,
+      transform: function (_, ret) {
+        delete ret._id;
+        delete ret.playerId;
+        delete ret.songHash;
+        delete ret.songDifficulty;
+        delete ret.songScore;
+        delete ret.__v;
+        return ret;
+      },
+    },
+  },
+})
+export class AdditionalScoreData {
+  /**
+   * The of the player who set the score.
+   */
+  @prop({ required: true, index: true })
+  public playerId!: string;
+
+  /**
+   * The hash of the song.
+   */
+  @prop({ required: true, index: true })
+  public songHash!: string;
+
+  /**
+   * The difficulty the score was set on.
+   */
+  @prop({ required: true, index: true })
+  public songDifficulty!: string;
+
+  /**
+   * The score of the play.
+   */
+  @prop({ required: true, index: true })
+  public songScore!: number;
+
+  // Above data is only so we can fetch it
+  // --------------------------------
+
+  /**
+   * The BeatLeader score id for this score.
+   */
+  @prop({ required: false })
+  public scoreId!: number;
+
+  /**
+   * The BeatLeader leaderboard id for this score.
+   */
+  @prop({ required: false })
+  public leaderboardId!: string;
+
+  /**
+   * The amount of pauses in the play.
+   */
+  @prop({ required: false })
+  public pauses!: number;
+
+  /**
+   * The miss data for the play.
+   */
+  @prop({ required: false, _id: false })
+  public misses!: Misses;
+
+  /**
+   * The hand accuracy for each hand.
+   * @private
+   */
+  @prop({ required: false, _id: false })
+  public handAccuracy!: HandAccuracy;
+
+  /**
+   * The full combo accuracy of the play.
+   */
+  @prop({ required: true })
+  public fcAccuracy!: number;
+
+  /**
+   * Whether the play was a full combo.
+   */
+  @prop({ required: true })
+  public fullCombo!: boolean;
+
+  /**
+   * The score improvement.
+   */
+  @prop({ required: false, _id: false })
+  public scoreImprovement?: {
+    /**
+     * The change in the score.
+     */
+    score: number;
+
+    /**
+     * The change in the accuracy.
+     */
+    accuracy: number;
+
+    /**
+     * The change in the misses.
+     */
+    misses: Misses;
+
+    /**
+     * The change in the hand accuracy.
+     */
+    handAccuracy: HandAccuracy;
+  };
+
+  /**
+   * The date the score was set on.
+   */
+  @prop({ required: true, index: true })
+  public timestamp!: Date;
+}
+
+export type AdditionalScoreDataDocument = AdditionalScoreData & Document;
+export const AdditionalScoreDataModel: ReturnModelType<typeof AdditionalScoreData> =
+  getModelForClass(AdditionalScoreData);

projects/common/src/model/additional-score-data/hand-accuracy.ts

@@ -0,0 +1,15 @@
+import { prop } from "@typegoose/typegoose";
+
+export class HandAccuracy {
+  /**
+   * The left hand accuracy.
+   */
+  @prop({ required: true })
+  left!: number;
+
+  /**
+   * The right hand accuracy.
+   */
+  @prop({ required: true })
+  right!: number;
+}

projects/common/src/model/additional-score-data/misses.ts

@@ -0,0 +1,33 @@
+import { prop } from "@typegoose/typegoose";
+
+export class Misses {
+  /**
+   * The amount of misses notes + bad cuts.
+   */
+  @prop({ required: true })
+  misses!: number;
+
+  /**
+   * The total amount of notes that were missed.
+   */
+  @prop({ required: true })
+  missedNotes!: number;
+
+  /**
+   * The amount of times a bomb was hit.
+   */
+  @prop({ required: true })
+  bombCuts!: number;
+
+  /**
+   * The amount of walls hit in the play.
+   */
+  @prop({ required: true })
+  wallsHit!: number;
+
+  /**
+   * The number of bad cuts.
+   */
+  @prop({ required: true })
+  badCuts!: number;
+}

projects/common/src/model/beatsaver/author.ts

@@ -0,0 +1,27 @@
+import { prop } from "@typegoose/typegoose";
+
+export default class BeatSaverAuthor {
+  /**
+   * The id of the author.
+   */
+  @prop({ required: true })
+  id: number;
+
+  /**
+   * The name of the mapper.
+   */
+  @prop({ required: true })
+  name: string;
+
+  /**
+   * The avatar URL for the mapper.
+   */
+  @prop({ required: true })
+  avatar: string;
+
+  constructor(id: number, name: string, avatar: string) {
+    this.id = id;
+    this.name = name;
+    this.avatar = avatar;
+  }
+}

projects/common/src/model/beatsaver/map-difficulty.ts

@@ -0,0 +1,128 @@
+import { prop } from "@typegoose/typegoose";
+import { type MapDifficulty } from "../../score/map-difficulty";
+
+export default class BeatSaverMapDifficulty {
+  /**
+   * The NJS of this difficulty.
+   */
+  @prop({ required: true })
+  njs: number;
+
+  /**
+   * The NJS offset of this difficulty.
+   */
+  @prop({ required: true })
+  offset: number;
+
+  /**
+   * The amount of notes in this difficulty.
+   */
+  @prop({ required: true })
+  notes: number;
+
+  /**
+   * The amount of bombs in this difficulty.
+   */
+  @prop({ required: true })
+  bombs: number;
+
+  /**
+   * The amount of obstacles in this difficulty.
+   */
+  @prop({ required: true })
+  obstacles: number;
+
+  /**
+   * The notes per second in this difficulty.
+   */
+  @prop({ required: true })
+  nps: number;
+
+  /**
+   * The characteristic of this difficulty.
+   */
+  @prop({ required: true, enum: ["Standard", "Lawless"] })
+  characteristic: "Standard" | "Lawless";
+
+  /**
+   * The difficulty level.
+   */
+  @prop({ required: true })
+  difficulty: MapDifficulty;
+
+  /**
+   * The amount of lighting events in this difficulty.
+   */
+  @prop({ required: true })
+  events: number;
+
+  /**
+   * Whether this difficulty uses Chroma.
+   */
+  @prop({ required: true, default: false })
+  chroma: boolean;
+
+  /**
+   * Does this difficulty use Mapping Extensions.
+   */
+  @prop({ required: true, default: false })
+  mappingExtensions: boolean;
+
+  /**
+   * Does this difficulty use Noodle Extensions.
+   */
+  @prop({ required: true, default: false })
+  noodleExtensions: boolean;
+
+  /**
+   * Whether this difficulty uses cinema mode.
+   */
+  @prop({ required: true, default: false })
+  cinema: boolean;
+
+  /**
+   * The maximum score achievable in this difficulty.
+   */
+  @prop({ required: true })
+  maxScore: number;
+
+  /**
+   * The custom label for this difficulty.
+   */
+  @prop()
+  label: string;
+
+  constructor(
+    njs: number,
+    offset: number,
+    notes: number,
+    bombs: number,
+    obstacles: number,
+    nps: number,
+    characteristic: "Standard" | "Lawless",
+    difficulty: MapDifficulty,
+    events: number,
+    chroma: boolean,
+    mappingExtensions: boolean,
+    noodleExtensions: boolean,
+    cinema: boolean,
+    maxScore: number,
+    label: string
+  ) {
+    this.njs = njs;
+    this.offset = offset;
+    this.notes = notes;
+    this.bombs = bombs;
+    this.obstacles = obstacles;
+    this.nps = nps;
+    this.characteristic = characteristic;
+    this.difficulty = difficulty;
+    this.events = events;
+    this.chroma = chroma;
+    this.mappingExtensions = mappingExtensions;
+    this.noodleExtensions = noodleExtensions;
+    this.cinema = cinema;
+    this.maxScore = maxScore;
+    this.label = label;
+  }
+}

projects/common/src/model/beatsaver/map-metadata.ts

@@ -0,0 +1,55 @@
+import { prop } from "@typegoose/typegoose";
+
+export default class BeatSaverMapMetadata {
+  /**
+   * The bpm of the song.
+   */
+  @prop({ required: true })
+  bpm: number;
+
+  /**
+   * The song's length in seconds.
+   */
+  @prop({ required: true })
+  duration: number;
+
+  /**
+   * The song's name.
+   */
+  @prop({ required: true })
+  songName: string;
+
+  /**
+   * The song's sub name.
+   */
+  @prop({ required: false })
+  songSubName: string;
+
+  /**
+   * The artist(s) name.
+   */
+  @prop({ required: true })
+  songAuthorName: string;
+
+  /**
+   * The level mapper(s) name.
+   */
+  @prop({ required: true })
+  levelAuthorName: string;
+
+  constructor(
+    bpm: number,
+    duration: number,
+    songName: string,
+    songSubName: string,
+    songAuthorName: string,
+    levelAuthorName: string
+  ) {
+    this.bpm = bpm;
+    this.duration = duration;
+    this.songName = songName;
+    this.songSubName = songSubName;
+    this.songAuthorName = songAuthorName;
+    this.levelAuthorName = levelAuthorName;
+  }
+}

projects/common/src/model/beatsaver/map-version.ts

@@ -0,0 +1,31 @@
+import { modelOptions, prop, Severity } from "@typegoose/typegoose";
+import BeatSaverMapDifficulty from "./map-difficulty";
+
+@modelOptions({
+  options: { allowMixed: Severity.ALLOW },
+})
+export default class BeatSaverMapVersion {
+  /**
+   * The hash of this map.
+   */
+  @prop({ required: true })
+  hash: string;
+
+  /**
+   * The date the map was created.
+   */
+  @prop({ required: true })
+  createdAt: Date;
+
+  /**
+   * The difficulties of this map.
+   */
+  @prop({ required: true })
+  difficulties: BeatSaverMapDifficulty[];
+
+  constructor(hash: string, createdAt: Date, difficulties: BeatSaverMapDifficulty[]) {
+    this.hash = hash;
+    this.createdAt = createdAt;
+    this.difficulties = difficulties;
+  }
+}

projects/common/src/model/beatsaver/map.ts

@@ -0,0 +1,99 @@
+import { getModelForClass, modelOptions, prop, ReturnModelType, Severity } from "@typegoose/typegoose";
+import { Document } from "mongoose";
+import BeatSaverAuthor from "./author";
+import BeatSaverMapVersion from "./map-version";
+import BeatSaverMapMetadata from "./map-metadata";
+
+/**
+ * The model for a BeatSaver map.
+ */
+@modelOptions({
+  options: { allowMixed: Severity.ALLOW },
+  schemaOptions: {
+    collection: "beatsaver-maps",
+    toObject: {
+      virtuals: true,
+      transform: function (_, ret) {
+        ret.id = ret._id;
+        delete ret._id;
+        delete ret.__v;
+        return ret;
+      },
+    },
+  },
+})
+export class BeatSaverMap {
+  /**
+   * The internal MongoDB ID (_id).
+   */
+  @prop({ required: true })
+  private _id!: string;
+
+  /**
+   * The name of the map.
+   */
+  @prop({ required: false })
+  public name!: string;
+
+  /**
+   * The description of the map.
+   */
+  @prop({ required: false })
+  public description!: string;
+
+  /**
+   * The bsr code for the map.
+   */
+  @prop({ required: false })
+  public bsr!: string;
+
+  /**
+   * The author of the map.
+   */
+  @prop({ required: false, _id: false, type: () => BeatSaverAuthor })
+  public author!: BeatSaverAuthor;
+
+  /**
+   * The versions of the map.
+   */
+  @prop({ required: false, _id: false, type: () => [BeatSaverMapVersion] })
+  public versions!: BeatSaverMapVersion[];
+
+  /**
+   * The metadata of the map.
+   */
+  @prop({ required: false, _id: false, type: () => BeatSaverMapMetadata })
+  public metadata!: BeatSaverMapMetadata;
+
+  /**
+   * True if the map is not found on beatsaver.
+   */
+  @prop({ required: false })
+  public notFound?: boolean;
+
+  /**
+   * The last time the map data was refreshed.
+   */
+  @prop({ required: true })
+  public lastRefreshed!: Date;
+
+  /**
+   * Exposes `id` as a virtual field mapped from `_id`.
+   */
+  public get id(): string {
+    return this._id;
+  }
+
+  /**
+   * Should the map data be refreshed?
+   *
+   * @returns true if the map data should be refreshed
+   */
+  public shouldRefresh(): boolean {
+    const now = new Date();
+    return now.getTime() - this.lastRefreshed.getTime() > 1000 * 60 * 60 * 24 * 3; // 3 days
+  }
+}
+
+export type BeatSaverMapDocument = BeatSaverMap & Document;
+export const BeatSaverMapModel: ReturnModelType<typeof BeatSaverMap> = getModelForClass(BeatSaverMap);

projects/common/src/model/player.ts

@@ -0,0 +1,113 @@
+import { getModelForClass, modelOptions, prop, ReturnModelType, Severity } from "@typegoose/typegoose";
+import { Document } from "mongoose";
+import { PlayerHistory } from "../player/player-history";
+import { formatDateMinimal, getDaysAgoDate, getMidnightAlignedDate } from "../utils/time-utils";
+
+/**
+ * The model for a player.
+ */
+@modelOptions({ options: { allowMixed: Severity.ALLOW } })
+export class Player {
+  /**
+   * The id of the player.
+   */
+  @prop()
+  public _id!: string;
+
+  /**
+   * The player's statistic history.
+   */
+  @prop()
+  private statisticHistory?: Record<string, PlayerHistory>;
+
+  /**
+   * The date the player was last tracked.
+   */
+  @prop()
+  public lastTracked?: Date;
+
+  /**
+   * The date the player was first tracked.
+   */
+  @prop()
+  public trackedSince?: Date;
+
+  /**
+   * Gets the player's statistic history.
+   */
+  public getStatisticHistory(): Record<string, PlayerHistory> {
+    if (this.statisticHistory === undefined) {
+      this.statisticHistory = {};
+    }
+    return this.statisticHistory;
+  }
+
+  /**
+   * Gets the player's history for a specific date.
+   *
+   * @param date the date to get the history for.
+   */
+  public getHistoryByDate(date: Date): PlayerHistory {
+    if (this.statisticHistory === undefined) {
+      this.statisticHistory = {};
+    }
+    return this.getStatisticHistory()[formatDateMinimal(getMidnightAlignedDate(date))] || {};
+  }
+
+  /**
+   * Gets the player's history for the previous X days.
+   *
+   * @param days the number of days to get the history for.
+   */
+  public getHistoryPreviousDays(days: number): Record<string, PlayerHistory> {
+    const statisticHistory = this.getStatisticHistory();
+    const history: Record<string, PlayerHistory> = {};
+
+    for (let i = 0; i <= days; i++) {
+      const date = formatDateMinimal(getMidnightAlignedDate(getDaysAgoDate(i)));
+      const playerHistory = statisticHistory[date];
+      if (playerHistory !== undefined && Object.keys(playerHistory).length > 0) {
+        history[date] = playerHistory;
+      }
+    }
+    return history;
+  }
+
+  /**
+   * Sets the player's statistic history.
+   *
+   * @param date the date to set it for.
+   * @param history the history to set.
+   */
+  public setStatisticHistory(date: Date, history: PlayerHistory) {
+    if (this.statisticHistory === undefined) {
+      this.statisticHistory = {};
+    }
+    this.statisticHistory[formatDateMinimal(getMidnightAlignedDate(date))] = history;
+  }
+
+  /**
+   * Sorts the player's statistic history by
+   * date in descending order. (oldest to newest)
+   */
+  public sortStatisticHistory() {
+    if (this.statisticHistory === undefined) {
+      this.statisticHistory = {};
+    }
+    this.statisticHistory = Object.fromEntries(
+      Object.entries(this.statisticHistory).sort((a, b) => new Date(b[0]).getTime() - new Date(a[0]).getTime())
+    );
+  }
+
+  /**
+   * Gets the number of days tracked.
+   *
+   * @returns the number of days tracked.
+   */
+  public getDaysTracked(): number {
+    return Object.keys(this.getStatisticHistory()).length;
+  }
+}
+
+export type PlayerDocument = Player & Document;
+export const PlayerModel: ReturnModelType<typeof Player> = getModelForClass(Player);

projects/common/src/model/score/impl/scoresaber-score.ts

@@ -0,0 +1,73 @@
+import { getModelForClass, modelOptions, plugin, Prop, ReturnModelType, Severity } from "@typegoose/typegoose";
+import Score from "../score";
+import { type ScoreSaberLeaderboardPlayerInfoToken } from "../../../types/token/scoresaber/score-saber-leaderboard-player-info-token";
+import { Document } from "mongoose";
+import { AutoIncrementID } from "@typegoose/auto-increment";
+
+@modelOptions({
+  options: { allowMixed: Severity.ALLOW },
+  schemaOptions: {
+    collection: "scoresaber-scores",
+    toObject: {
+      virtuals: true,
+      transform: function (_, ret) {
+        ret.id = ret._id;
+        delete ret._id;
+        delete ret.__v;
+        return ret;
+      },
+    },
+  },
+})
+@plugin(AutoIncrementID, {
+  field: "_id",
+  startAt: 1,
+  trackerModelName: "scores",
+  trackerCollection: "increments",
+  overwriteModelName: "scoresaber-scores",
+})
+export class ScoreSaberScoreInternal extends Score {
+  /**
+   * The score's id.
+   */
+  @Prop({ required: true, index: true })
+  public readonly scoreId!: string;
+
+  /**
+   * The leaderboard the score was set on.
+   */
+  @Prop({ required: true, index: true })
+  public readonly leaderboardId!: number;
+
+  /**
+   * The amount of pp for the score.
+   * @private
+   */
+  @Prop({ required: true })
+  public readonly pp!: number;
+
+  /**
+   * The weight of the score, or undefined if not ranked.
+   * @private
+   */
+  @Prop()
+  public readonly weight?: number;
+
+  /**
+   * The max combo of the score.
+   */
+  @Prop({ required: true })
+  public readonly maxCombo!: number;
+}
+
+class ScoreSaberScorePublic extends ScoreSaberScoreInternal {
+  /**
+   * The player who set the score.
+   */
+  public playerInfo!: ScoreSaberLeaderboardPlayerInfoToken;
+}
+
+export type ScoreSaberScore = InstanceType<typeof ScoreSaberScorePublic>;
+export type ScoreSaberScoreDocument = ScoreSaberScore & Document;
+export const ScoreSaberScoreModel: ReturnModelType<typeof ScoreSaberScoreInternal> =
+  getModelForClass(ScoreSaberScoreInternal);

projects/common/src/model/score/score.ts

@@ -0,0 +1,102 @@
+import { Modifier } from "../../score/modifier";
+import { AdditionalScoreData } from "../additional-score-data/additional-score-data";
+import { prop } from "@typegoose/typegoose";
+import { type MapDifficulty } from "../../score/map-difficulty";
+import { type MapCharacteristic } from "../../types/map-characteristic";
+
+/**
+ * The model for a score.
+ */
+export default class Score {
+  /**
+   * The internal score id.
+   */
+  @prop()
+  private _id?: number;
+
+  /**
+   * The id of the player who set the score.
+   */
+  @prop({ required: true, index: true })
+  public readonly playerId!: string;
+
+  /**
+   * The map difficulty played in the score.
+   */
+  @prop({ required: true })
+  public readonly difficulty!: MapDifficulty;
+
+  /**
+   * The characteristic of the map.
+   */
+  @prop({ required: true })
+  public readonly characteristic!: MapCharacteristic;
+
+  /**
+   * The base score for the score.
+   * @private
+   */
+  @prop({ required: true })
+  public readonly score!: number;
+
+  /**
+   * The accuracy of the score.
+   */
+  @prop({ required: true })
+  public readonly accuracy!: number;
+
+  /**
+   * The rank for the score.
+   * @private
+   */
+  @prop({ required: true })
+  public readonly rank!: number;
+
+  /**
+   * The modifiers used on the score.
+   * @private
+   */
+  @prop({ enum: () => Modifier, type: String, required: true })
+  public readonly modifiers!: Modifier[];
+
+  /**
+   * The total amount of misses.
+   * @private
+   */
+  @prop({ required: true })
+  public readonly misses!: number;
+
+  /**
+   * The amount of missed notes.
+   */
+  @prop({ required: true })
+  public readonly missedNotes!: number;
+
+  /**
+   * The amount of bad cuts.
+   * @private
+   */
+  @prop({ required: true })
+  public readonly badCuts!: number;
+
+  /**
+   * Whether every note was hit.
+   * @private
+   */
+  @prop({ required: true })
+  public readonly fullCombo!: boolean;
+
+  /**
+   * The additional data for the score.
+   */
+  public additionalData?: AdditionalScoreData;
+
+  /**
+   * The time the score was set.
+   * @private
+   */
+  @prop({ required: true })
+  public readonly timestamp!: Date;
+}
+
+export type ScoreType = InstanceType<typeof Score>;

projects/common/src/pagination.ts

@@ -0,0 +1,73 @@
+import { NotFoundError } from "backend/src/error/not-found-error";
+import { Metadata } from "./types/metadata";
+
+export class Pagination<T> {
+  /**
+   * The amount of items per page.
+   * @private
+   */
+  private itemsPerPage: number = 0;
+
+  /**
+   * The amount of items in total.
+   * @private
+   */
+  private totalItems: number = 0;
+
+  /**
+   * The items to paginate.
+   * @private
+   */
+  private items: T[] = [];
+
+  /**
+   * Sets the number of items per page.
+   *
+   * @param itemsPerPage - The number of items per page.
+   * @returns the pagination
+   */
+  setItemsPerPage(itemsPerPage: number): Pagination<T> {
+    this.itemsPerPage = itemsPerPage;
+    return this;
+  }
+
+  /**
+   * Sets the items to paginate.
+   *
+   * @param items the items to paginate
+   * @returns the pagination
+   */
+  setItems(items: T[]): Pagination<T> {
+    this.items = items;
+    this.totalItems = items.length;
+    return this;
+  }
+
+  /**
+   * Gets a page of items.
+   *
+   * @param page the page number to retrieve.
+   * @returns the page of items.
+   * @throws throws an error if the page number is invalid.
+   */
+  getPage(page: number): Page<T> {
+    const totalPages = Math.ceil(this.totalItems / this.itemsPerPage);
+
+    if (page < 1 || page > totalPages) {
+      throw new NotFoundError("Invalid page number");
+    }
+
+    const items = this.items.slice((page - 1) * this.itemsPerPage, page * this.itemsPerPage);
+    return new Page<T>(items, new Metadata(totalPages, this.totalItems, page, this.itemsPerPage));
+  }
+}
+
+class Page<T> {
+  readonly items: T[];
+  readonly metadata: Metadata;
+
+  constructor(items: T[], metadata: Metadata) {
+    this.items = items;
+    this.metadata = metadata;
+  }
+}

projects/common/src/player/impl/scoresaber-player.ts

@@ -0,0 +1,145 @@
+import Player, { StatisticChange } from "../player";
+import { PlayerHistory } from "../player-history";
+
+/**
+ * A ScoreSaber player.
+ */
+export default interface ScoreSaberPlayer extends Player {
+  /**
+   * The bio of the player.
+   */
+  bio: ScoreSaberBio;
+
+  /**
+   * The amount of pp the player has.
+   */
+  pp: number;
+
+  /**
+   * The change in pp compared to yesterday.
+   */
+  statisticChange: StatisticChange | undefined;
+
+  /**
+   * The role the player has.
+   */
+  role: string | undefined;
+
+  /**
+   * The badges the player has.
+   */
+  badges: ScoreSaberBadge[];
+
+  /**
+   * The rank history for this player.
+   */
+  statisticHistory: { [key: string]: PlayerHistory };
+
+  /**
+   * The statistics for this player.
+   */
+  statistics: ScoreSaberPlayerStatistics;
+
+  /**
+   * The permissions the player has.
+   */
+  permissions: number;
+
+  /**
+   * The pages for the players positions.
+   */
+  rankPages: ScoreSaberRankPages;
+
+  /**
+   * Whether the player is banned or not.
+   */
+  banned: boolean;
+
+  /**
+   * Whether the player is inactive or not.
+   */
+  inactive: boolean;
+
+  /**
+   * Whether the player is having their
+   * statistics being tracked or not.
+   */
+  isBeingTracked?: boolean;
+}
+
+/**
+ * A bio of a player.
+ */
+export type ScoreSaberBio = {
+  /**
+   * The lines of the bio including any html tags.
+   */
+  lines: string[];
+
+  /**
+   * The lines of the bio stripped of all html tags.
+   */
+  linesStripped: string[];
+};
+
+/**
+ * A badge for a player.
+ */
+export type ScoreSaberBadge = {
+  /**
+   * The URL to the badge.
+   */
+  url: string;
+
+  /**
+   * The description of the badge.
+   */
+  description: string;
+};
+
+/**
+ * The statistics for a player.
+ */
+export type ScoreSaberPlayerStatistics = {
+  /**
+   * The total amount of score accumulated over all scores.
+   */
+  totalScore: number;
+
+  /**
+   * The total amount of ranked score accumulated over all scores.
+   */
+  totalRankedScore: number;
+
+  /**
+   * The average ranked accuracy for all ranked scores.
+   */
+  averageRankedAccuracy: number;
+
+  /**
+   * The total amount of scores set.
+   */
+  totalPlayCount: number;
+
+  /**
+   * The total amount of ranked score set.
+   */
+  rankedPlayCount: number;
+
+  /**
+   * The amount of times their replays were watched.
+   */
+  replaysWatched: number;
+};
+
+export type ScoreSaberRankPages = {
+  /**
+   * Their page for their global rank position.
+   */
+  global: number;
+
+  /**
+   * Their page for their country rank position.
+   */
+  country: number;
+};

projects/common/src/player/player-history.ts

@@ -0,0 +1,71 @@
+export interface PlayerHistory {
+  /**
+   * The player's rank.
+   */
+  rank?: number;
+
+  /**
+   * The player's country rank.
+   */
+  countryRank?: number;
+
+  /**
+   * The pp of the player.
+   */
+  pp?: number;
+
+  /**
+   * How many times replays of the player scores have been watched
+   */
+  replaysWatched?: number;
+
+  /**
+   * The player's score stats.
+   */
+  score?: {
+    /**
+     * The total amount of unranked and ranked score.
+     */
+    totalScore?: number;
+
+    /**
+     * The total amount of ranked score.
+     */
+    totalRankedScore?: number;
+  };
+
+  /**
+   * The player's scores stats.
+   */
+  scores?: {
+    /**
+     * The amount of score set.
+     */
+    rankedScores?: number;
+
+    /**
+     * The amount of unranked scores set.
+     */
+    unrankedScores?: number;
+
+    /**
+     * The total amount of ranked scores
+     */
+    totalRankedScores?: number;
+
+    /**
+     * The total amount of scores
+     */
+    totalScores?: number;
+  };
+
+  /**
+   * The player's accuracy stats.
+   */
+  accuracy?: {
+    /**
+     * The player's average ranked accuracy.
+     */
+    averageRankedAccuracy?: number;
+  };
+}

projects/common/src/player/player-stat-change.ts

@@ -0,0 +1,64 @@
+import ScoreSaberPlayer from "./impl/scoresaber-player";
+import { ChangeRange } from "./player";
+
+export type PlayerStatValue = {
+  /**
+   * The type of the stat.
+   */
+  type: string;
+
+  /**
+   * The value of the stat.
+   */
+  value: (player: ScoreSaberPlayer, range: ChangeRange) => number | undefined;
+};
+
+export type PlayerStatChangeType =
+  | "Rank"
+  | "CountryRank"
+  | "PerformancePoints"
+  | "TotalPlayCount"
+  | "RankedPlayCount"
+  | "TotalScore"
+  | "TotalRankedScore"
+  | "AverageRankedAccuracy"
+  | "TotalReplaysWatched";
+
+export const PlayerStatChange: Record<PlayerStatChangeType, PlayerStatValue> = {
+  Rank: {
+    type: "Rank",
+    value: (player, range) => player.statisticChange?.[range].rank,
+  },
+  CountryRank: {
+    type: "Country Rank",
+    value: (player, range) => player.statisticChange?.[range].countryRank,
+  },
+  PerformancePoints: {
+    type: "Performance Points",
+    value: (player, range) => player.statisticChange?.[range].pp,
+  },
+  TotalPlayCount: {
+    type: "Total Play Count",
+    value: (player, range) => player.statisticChange?.[range].scores?.totalScores,
+  },
+  RankedPlayCount: {
+    type: "Ranked Play Count",
+    value: (player, range) => player.statisticChange?.[range].scores?.totalRankedScores,
+  },
+  TotalScore: {
+    type: "Total Score",
+    value: (player, range) => player.statisticChange?.[range].score?.totalScore,
+  },
+  TotalRankedScore: {
+    type: "Total Ranked Score",
+    value: (player, range) => player.statisticChange?.[range].score?.totalRankedScore,
+  },
+  AverageRankedAccuracy: {
+    type: "Average Ranked Accuracy",
+    value: (player, range) => player.statisticChange?.[range].accuracy?.averageRankedAccuracy,
+  },
+  TotalReplaysWatched: {
+    type: "Total Replays Watched",
+    value: (player, range) => player.statisticChange?.[range].replaysWatched,
+  },
+};

projects/common/src/player/player-tracked-since.ts

@@ -0,0 +1,11 @@
+export interface PlayerTrackedSince {
+  /**
+   * Whether the player statistics are being tracked
+   */
+  tracked: boolean;
+
+  /**
+   * The amount of days the player has been tracked
+   */
+  daysTracked?: number;
+}

projects/common/src/player/player.ts

@@ -0,0 +1,61 @@
+import { PlayerHistory } from "./player-history";
+
+export default class Player {
+  /**
+   * The ID of this player.
+   */
+  id: string;
+
+  /**
+   * The name of this player.
+   */
+  name: string;
+
+  /**
+   * The avatar url for this player.
+   */
+  avatar: string;
+
+  /**
+   * The country of this player.
+   */
+  country: string;
+
+  /**
+   * The rank of the player.
+   */
+  rank: number;
+
+  /**
+   * The rank the player has in their country.
+   */
+  countryRank: number;
+
+  /**
+   * The date the player joined the playform.
+   */
+  joinedDate: Date;
+
+  constructor(
+    id: string,
+    name: string,
+    avatar: string,
+    country: string,
+    rank: number,
+    countryRank: number,
+    joinedDate: Date
+  ) {
+    this.id = id;
+    this.name = name;
+    this.avatar = avatar;
+    this.country = country;
+    this.rank = rank;
+    this.countryRank = countryRank;
+    this.joinedDate = joinedDate;
+  }
+}
+
+export type ChangeRange = "daily" | "weekly" | "monthly";
+export type StatisticChange = {
+  [key in ChangeRange]: PlayerHistory;
+};

projects/common/src/response/around-player-response.ts

@@ -0,0 +1,8 @@
+import ScoreSaberPlayerToken from "../types/token/scoresaber/score-saber-player-token";
+
+export type AroundPlayerResponse = {
+  /**
+   * The players around the player.
+   */
+  players: ScoreSaberPlayerToken[];
+};

projects/common/src/response/leaderboard-response.ts

@@ -0,0 +1,13 @@
+import { BeatSaverMap } from "../model/beatsaver/map";
+
+export type LeaderboardResponse<L> = {
+  /**
+   * The leaderboard.
+   */
+  leaderboard: L;
+
+  /**
+   * The beatsaver map.
+   */
+  beatsaver?: BeatSaverMap;
+};

projects/common/src/response/leaderboard-scores-response.ts

@@ -0,0 +1,24 @@
+import { Metadata } from "../types/metadata";
+import { BeatSaverMap } from "../model/beatsaver/map";
+
+export default interface LeaderboardScoresResponse<S, L> {
+  /**
+   * The scores that were set.
+   */
+  readonly scores: S[];
+
+  /**
+   * The leaderboard that was used.
+   */
+  readonly leaderboard: L;
+
+  /**
+   * The beatsaver map for the song.
+   */
+  readonly beatSaver?: BeatSaverMap;
+
+  /**
+   * The pagination metadata.
+   */
+  readonly metadata: Metadata;
+}

projects/common/src/response/player-scores-response.ts

@@ -0,0 +1,14 @@
+import { Metadata } from "../types/metadata";
+import { PlayerScore } from "../score/player-score";
+
+export default interface PlayerScoresResponse<S, L> {
+  /**
+   * The scores that were set.
+   */
+  readonly scores: PlayerScore<S, L>[];
+
+  /**
+   * The pagination metadata.
+   */
+  readonly metadata: Metadata;
+}

projects/common/src/score/map-difficulty.ts

@@ -0,0 +1 @@
+export type MapDifficulty = "Easy" | "Normal" | "Hard" | "Expert" | "ExpertPlus" | "Unknown";

projects/common/src/score/modifier.ts

@@ -0,0 +1,19 @@
+/**
+ * The score modifiers.
+ */
+export enum Modifier {
+  NF = "No Fail",
+  PM = "Pro Mode",
+  FS = "Faster Song",
+  SF = "Super Fast Song",
+  SS = "Slower Song",
+  GN = "Ghost Notes",
+  DA = "Disappearing Arrows",
+  SA = "Strict Angles",
+  SC = "Small Notes",
+  IF = "One Life",
+  NO = "No Obstacles",
+  BE = "Battery Energy",
+  NB = "No Bombs",
+  NA = "No Arrows",
+}

projects/common/src/score/player-leaderboard-score.ts

@@ -0,0 +1,6 @@
+export default interface PlayerLeaderboardScore<S> {
+  /**
+   * The score that was set.
+   */
+  readonly score: S;
+}

projects/common/src/score/player-score.ts

@@ -0,0 +1,18 @@
+import { BeatSaverMap } from "../model/beatsaver/map";
+
+export interface PlayerScore<S, L> {
+  /**
+   * The score.
+   */
+  readonly score: S;
+
+  /**
+   * The leaderboard the score was set on.
+   */
+  readonly leaderboard: L;
+
+  /**
+   * The BeatSaver of the song.
+   */
+  readonly beatSaver?: BeatSaverMap;
+}

projects/common/src/service/impl/beatleader.ts

@@ -0,0 +1,34 @@
+import Service from "../service";
+import { ScoreStatsToken } from "../../types/token/beatleader/score-stats/score-stats";
+
+const LOOKUP_MAP_STATS_BY_SCORE_ID_ENDPOINT = `https://cdn.scorestats.beatleader.xyz/:scoreId.json`;
+
+class BeatLeaderService extends Service {
+  constructor() {
+    super("BeatLeader");
+  }
+
+  /**
+   * Looks up the score stats for a score
+   *
+   * @param scoreId the score id to get
+   * @returns the score stats, or undefined if nothing was found
+   */
+  async lookupScoreStats(scoreId: number): Promise<ScoreStatsToken | undefined> {
+    const before = performance.now();
+    this.log(`Looking score stats for "${scoreId}"...`);
+
+    const response = await this.fetch<ScoreStatsToken>(
+      LOOKUP_MAP_STATS_BY_SCORE_ID_ENDPOINT.replace(":scoreId", scoreId + "")
+    );
+    // Score stats not found
+    if (response == undefined) {
+      return undefined;
+    }
+
+    this.log(`Found score stats for score "${scoreId}" in ${(performance.now() - before).toFixed(0)}ms`);
+    return response;
+  }
+}
+
+export const beatLeaderService = new BeatLeaderService();

projects/common/src/service/impl/beatsaver.ts

@@ -0,0 +1,33 @@
+import Service from "../service";
+import { BeatSaverMapToken } from "../../types/token/beatsaver/map";
+
+const API_BASE = "https://api.beatsaver.com";
+const LOOKUP_MAP_BY_HASH_ENDPOINT = `${API_BASE}/maps/hash/:query`;
+
+class BeatSaverService extends Service {
+  constructor() {
+    super("BeatSaver");
+  }
+
+  /**
+   * Gets the map that match the query.
+   *
+   * @param query the query to search for
+   * @returns the map that match the query, or undefined if no map were found
+   */
+  async lookupMap(query: string): Promise<BeatSaverMapToken | undefined> {
+    const before = performance.now();
+    this.log(`Looking up map "${query}"...`);
+
+    const response = await this.fetch<BeatSaverMapToken>(LOOKUP_MAP_BY_HASH_ENDPOINT.replace(":query", query));
+    // Map not found
+    if (response == undefined) {
+      return undefined;
+    }
+
+    this.log(`Found map "${response.id}" in ${(performance.now() - before).toFixed(0)}ms`);
+    return response;
+  }
+}
+
+export const beatsaverService = new BeatSaverService();

projects/common/src/service/impl/scoresaber.ts

@@ -0,0 +1,299 @@
+import Service from "../service";
+import { ScoreSaberPlayerSearchToken } from "../../types/token/scoresaber/score-saber-player-search-token";
+import ScoreSaberPlayerToken from "../../types/token/scoresaber/score-saber-player-token";
+import { ScoreSaberPlayersPageToken } from "../../types/token/scoresaber/score-saber-players-page-token";
+import { ScoreSort } from "../../score/score-sort";
+import ScoreSaberPlayerScoresPageToken from "../../types/token/scoresaber/score-saber-player-scores-page-token";
+import ScoreSaberLeaderboardToken from "../../types/token/scoresaber/score-saber-leaderboard-token";
+import ScoreSaberLeaderboardScoresPageToken from "../../types/token/scoresaber/score-saber-leaderboard-scores-page-token";
+import { clamp, lerp } from "../../utils/math-utils";
+import { CurvePoint } from "../../utils/curve-point";
+import { SSRCache } from "../../cache";
+
+const API_BASE = "https://scoresaber.com/api";
+
+/**
+ * Player
+ */
+const SEARCH_PLAYERS_ENDPOINT = `${API_BASE}/players?search=:query`;
+const LOOKUP_PLAYER_ENDPOINT = `${API_BASE}/player/:id/full`;
+const LOOKUP_PLAYERS_ENDPOINT = `${API_BASE}/players?page=:page`;
+const LOOKUP_PLAYERS_BY_COUNTRY_ENDPOINT = `${API_BASE}/players?page=:page&countries=:country`;
+const LOOKUP_PLAYER_SCORES_ENDPOINT = `${API_BASE}/player/:id/scores?limit=:limit&sort=:sort&page=:page`;
+
+/**
+ * Leaderboard
+ */
+const LOOKUP_LEADERBOARD_ENDPOINT = `${API_BASE}/leaderboard/by-id/:id/info`;
+const LOOKUP_LEADERBOARD_SCORES_ENDPOINT = `${API_BASE}/leaderboard/by-id/:id/scores?page=:page`;
+
+const STAR_MULTIPLIER = 42.117208413;
+
+const playerCache = new SSRCache({
+  ttl: 60 * 30, // 30 minutes
+});
+
+class ScoreSaberService extends Service {
+  private curvePoints = [
+    new CurvePoint(0, 0),
+    new CurvePoint(0.6, 0.18223233667439062),
+    new CurvePoint(0.65, 0.5866010012767576),
+    new CurvePoint(0.7, 0.6125565959114954),
+    new CurvePoint(0.75, 0.6451808210101443),
+    new CurvePoint(0.8, 0.6872268862950283),
+    new CurvePoint(0.825, 0.7150465663454271),
+    new CurvePoint(0.85, 0.7462290664143185),
+    new CurvePoint(0.875, 0.7816934560296046),
+    new CurvePoint(0.9, 0.825756123560842),
+    new CurvePoint(0.91, 0.8488375988124467),
+    new CurvePoint(0.92, 0.8728710341448851),
+    new CurvePoint(0.93, 0.9039994071865736),
+    new CurvePoint(0.94, 0.9417362980580238),
+    new CurvePoint(0.95, 1),
+    new CurvePoint(0.955, 1.0388633331418984),
+    new CurvePoint(0.96, 1.0871883573850478),
+    new CurvePoint(0.965, 1.1552120359501035),
+    new CurvePoint(0.97, 1.2485807759957321),
+    new CurvePoint(0.9725, 1.3090333065057616),
+    new CurvePoint(0.975, 1.3807102743105126),
+    new CurvePoint(0.9775, 1.4664726399289512),
+    new CurvePoint(0.98, 1.5702410055532239),
+    new CurvePoint(0.9825, 1.697536248647543),
+    new CurvePoint(0.985, 1.8563887693647105),
+    new CurvePoint(0.9875, 2.058947159052738),
+    new CurvePoint(0.99, 2.324506282149922),
+    new CurvePoint(0.99125, 2.4902905794106913),
+    new CurvePoint(0.9925, 2.685667856592722),
+    new CurvePoint(0.99375, 2.9190155639254955),
+    new CurvePoint(0.995, 3.2022017597337955),
+    new CurvePoint(0.99625, 3.5526145337555373),
+    new CurvePoint(0.9975, 3.996793606763322),
+    new CurvePoint(0.99825, 4.325027383589547),
+    new CurvePoint(0.999, 4.715470646416203),
+    new CurvePoint(0.9995, 5.019543595874787),
+    new CurvePoint(1, 5.367394282890631),
+  ];
+
+  constructor() {
+    super("ScoreSaber");
+  }
+
+  /**
+   * Gets the players that match the query.
+   *
+   * @param query the query to search for
+   * @returns the players that match the query, or undefined if no players were found
+   */
+  public async searchPlayers(query: string): Promise<ScoreSaberPlayerSearchToken | undefined> {
+    const before = performance.now();
+    this.log(`Searching for players matching "${query}"...`);
+    const results = await this.fetch<ScoreSaberPlayerSearchToken>(SEARCH_PLAYERS_ENDPOINT.replace(":query", query));
+    if (results === undefined) {
+      return undefined;
+    }
+    if (results.players.length === 0) {
+      return undefined;
+    }
+    results.players.sort((a, b) => a.rank - b.rank);
+    this.log(`Found ${results.players.length} players in ${(performance.now() - before).toFixed(0)}ms`);
+    return results;
+  }
+
+  /**
+   * Looks up a player by their ID.
+   *
+   * @param playerId the ID of the player to look up
+   * @param cache whether to use the local cache
+   * @returns the player that matches the ID, or undefined
+   */
+  public async lookupPlayer(playerId: string, cache: boolean = false): Promise<ScoreSaberPlayerToken | undefined> {
+    if (cache && playerCache.has(playerId)) {
+      return playerCache.get(playerId);
+    }
+    const before = performance.now();
+    this.log(`Looking up player "${playerId}"...`);
+    const token = await this.fetch<ScoreSaberPlayerToken>(LOOKUP_PLAYER_ENDPOINT.replace(":id", playerId));
+    if (token === undefined) {
+      return undefined;
+    }
+    this.log(`Found player "${playerId}" in ${(performance.now() - before).toFixed(0)}ms`);
+    if (cache) {
+      playerCache.set(playerId, token);
+    }
+    return token;
+  }
+
+  /**
+   * Lookup players on a specific page
+   *
+   * @param page the page to get players for
+   * @returns the players on the page, or undefined
+   */
+  public async lookupPlayers(page: number): Promise<ScoreSaberPlayersPageToken | undefined> {
+    const before = performance.now();
+    this.log(`Looking up players on page "${page}"...`);
+    const response = await this.fetch<ScoreSaberPlayersPageToken>(
+      LOOKUP_PLAYERS_ENDPOINT.replace(":page", page.toString())
+    );
+    if (response === undefined) {
+      return undefined;
+    }
+    this.log(`Found ${response.players.length} players in ${(performance.now() - before).toFixed(0)}ms`);
+    return response;
+  }
+
+  /**
+   * Lookup players on a specific page and country
+   *
+   * @param page the page to get players for
+   * @param country the country to get players for
+   * @returns the players on the page, or undefined
+   */
+  public async lookupPlayersByCountry(page: number, country: string): Promise<ScoreSaberPlayersPageToken | undefined> {
+    const before = performance.now();
+    this.log(`Looking up players on page "${page}" for country "${country}"...`);
+    const response = await this.fetch<ScoreSaberPlayersPageToken>(
+      LOOKUP_PLAYERS_BY_COUNTRY_ENDPOINT.replace(":page", page.toString()).replace(":country", country)
+    );
+    if (response === undefined) {
+      return undefined;
+    }
+    this.log(`Found ${response.players.length} players in ${(performance.now() - before).toFixed(0)}ms`);
+    return response;
+  }
+
+  /**
+   * Looks up a page of scores for a player
+   *
+   * @param playerId the ID of the player to look up
+   * @param sort the sort to use
+   * @param page the page to get scores for
+   * @param limit the amount of scores to fetch
+   * @param search
+   * @returns the scores of the player, or undefined
+   */
+  public async lookupPlayerScores({
+    playerId,
+    sort,
+    page,
+    limit = 8,
+    search,
+  }: {
+    playerId: string;
+    sort: ScoreSort;
+    page: number;
+    limit?: number;
+    search?: string;
+    useProxy?: boolean;
+  }): Promise<ScoreSaberPlayerScoresPageToken | undefined> {
+    const before = performance.now();
+    this.log(
+      `Looking up scores for player "${playerId}", sort "${sort}", page "${page}"${search ? `, search "${search}"` : ""}...`
+    );
+    const response = await this.fetch<ScoreSaberPlayerScoresPageToken>(
+      LOOKUP_PLAYER_SCORES_ENDPOINT.replace(":id", playerId)
+        .replace(":limit", limit + "")
+        .replace(":sort", sort)
+        .replace(":page", page + "") + (search ? `&search=${search}` : "")
+    );
+    if (response === undefined) {
+      return undefined;
+    }
+    this.log(
+      `Found ${response.playerScores.length} scores for player "${playerId}" in ${(performance.now() - before).toFixed(0)}ms`
+    );
+    return response;
+  }
+
+  /**
+   * Looks up a leaderboard
+   *
+   * @param leaderboardId the ID of the leaderboard to look up
+   */
+  public async lookupLeaderboard(leaderboardId: string): Promise<ScoreSaberLeaderboardToken | undefined> {
+    const before = performance.now();
+    this.log(`Looking up leaderboard "${leaderboardId}"...`);
+    const response = await this.fetch<ScoreSaberLeaderboardToken>(
+      LOOKUP_LEADERBOARD_ENDPOINT.replace(":id", leaderboardId)
+    );
+    if (response === undefined) {
+      return undefined;
+    }
+    this.log(`Found leaderboard "${leaderboardId}" in ${(performance.now() - before).toFixed(0)}ms`);
+    return response;
+  }
+
+  /**
+   * Looks up a page of scores for a leaderboard
+   *
+   * @param leaderboardId the ID of the leaderboard to look up
+   * @param page the page to get scores for
+   * @returns the scores of the leaderboard, or undefined
+   */
+  public async lookupLeaderboardScores(
+    leaderboardId: string,
+    page: number
+  ): Promise<ScoreSaberLeaderboardScoresPageToken | undefined> {
+    const before = performance.now();
+    this.log(`Looking up scores for leaderboard "${leaderboardId}", page "${page}"...`);
+    const response = await this.fetch<ScoreSaberLeaderboardScoresPageToken>(
+      LOOKUP_LEADERBOARD_SCORES_ENDPOINT.replace(":id", leaderboardId).replace(":page", page.toString())
+    );
+    if (response === undefined) {
+      return undefined;
+    }
+    this.log(
+      `Found ${response.scores.length} scores for leaderboard "${leaderboardId}" in ${(performance.now() - before).toFixed(0)}ms`
+    );
+    return response;
+  }
+
+  /**
+   * Gets the modifier for the given accuracy.
+   *
+   * @param accuracy The accuracy.
+   * @return The modifier.
+   */
+  public getModifier(accuracy: number): number {
+    accuracy = clamp(accuracy, 0, 100) / 100; // Normalize accuracy to a range of [0, 1]
+
+    if (accuracy <= 0) {
+      return 0;
+    }
+
+    if (accuracy >= 1) {
+      return this.curvePoints[this.curvePoints.length - 1].getMultiplier();
+    }
+
+    for (let i = 0; i < this.curvePoints.length - 1; i++) {
+      const point = this.curvePoints[i];
+      const nextPoint = this.curvePoints[i + 1];
+      if (accuracy >= point.getAcc() && accuracy <= nextPoint.getAcc()) {
+        return lerp(
+          point.getMultiplier(),
+          nextPoint.getMultiplier(),
+          (accuracy - point.getAcc()) / (nextPoint.getAcc() - point.getAcc())
+        );
+      }
+    }
+
+    return 0;
+  }
+
+  /**
+   * Gets the performance points (PP) based on stars and accuracy.
+   *
+   * @param stars The star count.
+   * @param accuracy The accuracy.
+   * @returns The calculated PP.
+   */
+  public getPp(stars: number, accuracy: number): number {
+    if (accuracy <= 1) {
+      accuracy *= 100; // Convert the accuracy to a percentage
+    }
+    const pp = stars * STAR_MULTIPLIER; // Calculate base PP value
+    return this.getModifier(accuracy) * pp; // Calculate and return final PP value
+  }
+}
+
+export const scoresaberService = new ScoreSaberService();

projects/common/src/service/service.ts

@@ -1,10 +1,11 @@
 import ky from "ky";
+import { isServer } from "../utils/utils";
 
-export default class DataFetcher {
+export default class Service {
   /**
-   * The name of the leaderboard.
+   * The name of the service.
    */
-  private name: string;
+  private readonly name: string;
 
   constructor(name: string) {
     this.name = name;
@@ -33,21 +34,17 @@ export default class DataFetcher {
   /**
    * Fetches data from the given url.
    *
-   * @param useProxy whether to use proxy or not
    * @param url the url to fetch
    * @returns the fetched data
    */
-  public async fetch<T>(useProxy: boolean, url: string): Promise<T | undefined> {
+  public async fetch<T>(url: string): Promise<T | undefined> {
     try {
-      return await ky
-        .get<T>(this.buildRequestUrl(useProxy, url), {
-          next: {
-            revalidate: 60, // 1 minute
-          },
-        })
-        .json();
+      const response = await ky.get<T>(this.buildRequestUrl(!isServer(), url));
+      if (response.headers.has("X-RateLimit-Remaining")) {
+        this.log(`Rate limit remaining: ${response.headers.get("X-RateLimit-Remaining")}`);
+      }
+      return response.json();
     } catch (error) {
-      console.error(`Error fetching data from ${url}:`, error);
       return undefined;
     }
   }

projects/common/src/sorter/impl/scoresaber-sorter.ts

@@ -0,0 +1,69 @@
+import { ScoreSorter } from "../score-sorter";
+import { ScoreSaberScore } from "../../model/score/impl/scoresaber-score";
+import { ScoreSortType } from "../sort-type";
+import { SortDirection } from "../sort-direction";
+
+export class ScoreSaberScoreSorter extends ScoreSorter<ScoreSaberScore> {
+  sort(type: ScoreSortType, direction: SortDirection, items: ScoreSaberScore[]): ScoreSaberScore[] {
+    switch (type) {
+      case ScoreSortType.date:
+        return this.sortRecent(direction, items);
+      case ScoreSortType.pp:
+        return this.sortPp(direction, items);
+      case ScoreSortType.accuracy:
+        return this.sortAccuracy(direction, items);
+      case ScoreSortType.misses:
+        return this.sortMisses(direction, items);
+      default:
+        return items;
+    }
+  }
+
+  /**
+   * Sorts the scores by the time they were set.
+   *
+   * @param direction the direction to sort the scores
+   * @param items the scores to sort
+   * @returns the sorted scores
+   */
+  sortRecent(direction: SortDirection, items: ScoreSaberScore[]): ScoreSaberScore[] {
+    return items.sort((a, b) =>
+      direction === SortDirection.ASC
+        ? a.timestamp.getTime() - b.timestamp.getTime()
+        : b.timestamp.getTime() - a.timestamp.getTime()
+    );
+  }
+
+  /**
+   * Sorts the scores by their pp value
+   *
+   * @param direction the direction to sort the scores
+   * @param items the scores to sort
+   * @returns the sorted scores
+   */
+  sortPp(direction: SortDirection, items: ScoreSaberScore[]): ScoreSaberScore[] {
+    return items.sort((a, b) => (direction === SortDirection.ASC ? a.pp - b.pp : b.pp - a.pp));
+  }
+
+  /**
+   * Sorts the scores by their accuracy value
+   *
+   * @param direction the direction to sort the scores
+   * @param items the scores to sort
+   * @returns the sorted scores
+   */
+  sortAccuracy(direction: SortDirection, items: ScoreSaberScore[]): ScoreSaberScore[] {
+    return items.sort((a, b) => (direction === SortDirection.ASC ? a.accuracy - b.accuracy : b.accuracy - a.accuracy));
+  }
+
+  /**
+   * Sorts the scores by their misses
+   *
+   * @param direction the direction to sort the scores
+   * @param items the scores to sort
+   * @returns the sorted scores
+   */
+  sortMisses(direction: SortDirection, items: ScoreSaberScore[]): ScoreSaberScore[] {
+    return items.sort((a, b) => (direction === SortDirection.ASC ? a.misses - b.misses : b.misses - a.misses));
+  }
+}

projects/common/src/sorter/score-sorter.ts

@@ -0,0 +1,14 @@
+import { ScoreSortType } from "./sort-type";
+import { SortDirection } from "./sort-direction";
+
+export abstract class ScoreSorter<T> {
+  /**
+   * Sorts the items
+   *
+   * @param type the type of sort
+   * @param direction the direction of the sort
+   * @param items the items to sort
+   * @returns the sorted items
+   */
+  public abstract sort(type: ScoreSortType, direction: SortDirection, items: T[]): T[];
+}

projects/common/src/sorter/sort-direction.ts

@@ -0,0 +1,4 @@
+export enum SortDirection {
+  ASC = "asc",
+  DESC = "desc",
+}

projects/common/src/sorter/sort-type.ts

@@ -0,0 +1,6 @@
+export enum ScoreSortType {
+  date = "date",
+  pp = "pp",
+  accuracy = "accuracy",
+  misses = "misses",
+}

projects/common/src/sorter/sorters.ts

@@ -0,0 +1,5 @@
+import { ScoreSaberScoreSorter } from "./impl/scoresaber-sorter";
+
+export const ScoreSorters = {
+  scoreSaber: new ScoreSaberScoreSorter(),
+};

projects/common/src/token-creators.ts

@@ -0,0 +1,331 @@
+import ScoreSaberLeaderboard from "./leaderboard/impl/scoresaber-leaderboard";
+import ScoreSaberLeaderboardToken from "./types/token/scoresaber/score-saber-leaderboard-token";
+import LeaderboardDifficulty from "./leaderboard/leaderboard-difficulty";
+import { getDifficultyFromScoreSaberDifficulty } from "./utils/scoresaber-utils";
+import { MapCharacteristic } from "./types/map-characteristic";
+import { LeaderboardStatus } from "./leaderboard/leaderboard-status";
+import { formatDateMinimal, getDaysAgoDate, getMidnightAlignedDate, parseDate } from "./utils/time-utils";
+import ScoreSaberPlayerToken from "./types/token/scoresaber/score-saber-player-token";
+import ScoreSaberPlayer, { ScoreSaberBadge, ScoreSaberBio } from "./player/impl/scoresaber-player";
+import { PlayerHistory } from "./player/player-history";
+import ky from "ky";
+import { Config } from "./config";
+import { getValueFromHistory } from "./utils/player-utils";
+import { getPageFromRank } from "./utils/utils";
+import ScoreSaberScoreToken from "./types/token/scoresaber/score-saber-score-token";
+import { ScoreSaberScore } from "./model/score/impl/scoresaber-score";
+import { Modifier } from "./score/modifier";
+
+/**
+ * Parses a {@link ScoreSaberLeaderboardToken} into a {@link ScoreSaberLeaderboard}.
+ *
+ * @param token the token to parse
+ */
+export function getScoreSaberLeaderboardFromToken(token: ScoreSaberLeaderboardToken): ScoreSaberLeaderboard {
+  const difficulty: LeaderboardDifficulty = {
+    leaderboardId: token.difficulty.leaderboardId,
+    difficulty: getDifficultyFromScoreSaberDifficulty(token.difficulty.difficulty),
+    characteristic: token.difficulty.gameMode.replace("Solo", "") as MapCharacteristic,
+    difficultyRaw: token.difficulty.difficultyRaw,
+  };
+
+  let status: LeaderboardStatus = "Unranked";
+  if (token.qualified) {
+    status = "Qualified";
+  } else if (token.ranked) {
+    status = "Ranked";
+  }
+
+  return {
+    id: token.id,
+    songHash: token.songHash.toUpperCase(),
+    songName: token.songName,
+    songSubName: token.songSubName,
+    songAuthorName: token.songAuthorName,
+    levelAuthorName: token.levelAuthorName,
+    difficulty: difficulty,
+    difficulties:
+      token.difficulties != undefined && token.difficulties.length > 0
+        ? token.difficulties.map(difficulty => {
+            return {
+              leaderboardId: difficulty.leaderboardId,
+              difficulty: getDifficultyFromScoreSaberDifficulty(difficulty.difficulty),
+              characteristic: difficulty.gameMode.replace("Solo", "") as MapCharacteristic,
+              difficultyRaw: difficulty.difficultyRaw,
+            };
+          })
+        : [difficulty],
+    maxScore: token.maxScore,
+    ranked: token.ranked,
+    songArt: token.coverImage,
+    timestamp: parseDate(token.createdDate),
+    stars: token.stars,
+    plays: token.plays,
+    dailyPlays: token.dailyPlays,
+    qualified: token.qualified,
+    status: status,
+  };
+}
+
+/**
+ * Gets a {@link ScoreSaberScore} from a {@link ScoreSaberScoreToken}.
+ *
+ * @param token the token to convert
+ * @param playerId the id of the player who set the score
+ * @param leaderboard the leaderboard the score was set on
+ */
+export function getScoreSaberScoreFromToken(
+  token: ScoreSaberScoreToken,
+  leaderboard: ScoreSaberLeaderboard,
+  playerId?: string
+): ScoreSaberScore {
+  const modifiers: Modifier[] =
+    token.modifiers == undefined || token.modifiers === ""
+      ? []
+      : token.modifiers.split(",").map(mod => {
+          mod = mod.toUpperCase();
+          const modifier = Modifier[mod as keyof typeof Modifier];
+          if (modifier === undefined) {
+            throw new Error(`Unknown modifier: ${mod}`);
+          }
+          return modifier;
+        });
+
+  return {
+    playerId: playerId || token.leaderboardPlayerInfo.id,
+    leaderboardId: leaderboard.id,
+    difficulty: leaderboard.difficulty.difficulty,
+    characteristic: leaderboard.difficulty.characteristic,
+    score: token.baseScore,
+    accuracy: (token.baseScore / leaderboard.maxScore) * 100,
+    rank: token.rank,
+    modifiers: modifiers,
+    misses: token.missedNotes + token.badCuts,
+    missedNotes: token.missedNotes,
+    badCuts: token.badCuts,
+    fullCombo: token.fullCombo,
+    timestamp: new Date(token.timeSet),
+    scoreId: token.id,
+    pp: token.pp,
+    weight: token.weight,
+    maxCombo: token.maxCombo,
+    playerInfo: token.leaderboardPlayerInfo,
+  };
+}
+
+/**
+ * Gets the ScoreSaber Player from an {@link ScoreSaberPlayerToken}.
+ *
+ * @param token the player token
+ * @param playerIdCookie the id of the claimed player
+ */
+export async function getScoreSaberPlayerFromToken(
+  token: ScoreSaberPlayerToken,
+  playerIdCookie?: string
+): Promise<ScoreSaberPlayer> {
+  const bio: ScoreSaberBio = {
+    lines: token.bio?.split("\n") || [],
+    linesStripped: token.bio?.replace(/<[^>]+>/g, "")?.split("\n") || [], // strips html tags
+  };
+  const badges: ScoreSaberBadge[] =
+    token.badges?.map(badge => {
+      return {
+        url: badge.image,
+        description: badge.description,
+      };
+    }) || [];
+
+  let isBeingTracked = false;
+  const todayDate = formatDateMinimal(getMidnightAlignedDate(new Date()));
+  let statisticHistory: { [key: string]: PlayerHistory } = {};
+
+  try {
+    const { statistics: history } = await ky
+      .get<{
+        statistics: { [key: string]: PlayerHistory };
+      }>(
+        `${Config.apiUrl}/player/history/${token.id}/50/${playerIdCookie && playerIdCookie == token.id ? "?createIfMissing=true" : ""}`
+      )
+      .json();
+    if (history) {
+      // Use the latest data for today
+      history[todayDate] = {
+        ...history[todayDate],
+        rank: token.rank,
+        countryRank: token.countryRank,
+        pp: token.pp,
+        replaysWatched: token.scoreStats.replaysWatched,
+        accuracy: {
+          ...history[todayDate]?.accuracy,
+          averageRankedAccuracy: token.scoreStats.averageRankedAccuracy,
+        },
+        scores: {
+          ...history[todayDate]?.scores,
+          totalScores: token.scoreStats.totalPlayCount,
+          totalRankedScores: token.scoreStats.rankedPlayCount,
+        },
+        score: {
+          ...history[todayDate]?.score,
+          totalScore: token.scoreStats.totalScore,
+          totalRankedScore: token.scoreStats.totalRankedScore,
+        },
+      };
+
+      isBeingTracked = true;
+    }
+    statisticHistory = history;
+  } catch (e) {}
+
+  const playerRankHistory = token.histories.split(",").map(value => {
+    return parseInt(value);
+  });
+  playerRankHistory.push(token.rank);
+
+  let missingDays = 0;
+  let daysAgo = 0; // Start from current day
+  for (let i = playerRankHistory.length - 1; i >= 0; i--) {
+    const rank = playerRankHistory[i];
+    if (rank == 999_999) {
+      continue;
+    }
+
+    const date = getMidnightAlignedDate(getDaysAgoDate(daysAgo));
+    daysAgo += 1;
+
+    const dateKey = formatDateMinimal(date);
+    if (!statisticHistory[dateKey] || statisticHistory[dateKey].rank == undefined) {
+      missingDays += 1;
+      statisticHistory[dateKey] = {
+        ...statisticHistory[dateKey],
+        rank: rank,
+      };
+    }
+  }
+
+  if (missingDays > 0 && missingDays != playerRankHistory.length) {
+    console.log(
+      `Player has ${missingDays} missing day${missingDays > 1 ? "s" : ""}, filling in with fallback history...`
+    );
+  }
+
+  // Sort the fallback history
+  statisticHistory = Object.entries(statisticHistory)
+    .sort((a, b) => Date.parse(b[0]) - Date.parse(a[0]))
+    .reduce((obj, [key, value]) => ({ ...obj, [key]: value }), {});
+
+  /**
+   * Gets the change in the given stat
+   *
+   * @param statType the stat to check
+   * @param isNegativeChange whether to multiply the change by 1 or -1
+   * @param daysAgo the amount of days ago to get the stat for
+   * @return the change
+   */
+  const getStatisticChange = (statType: string, isNegativeChange: boolean, daysAgo: number = 1): number | undefined => {
+    const todayStats = statisticHistory[todayDate];
+    let otherDate: Date | undefined;
+
+    if (daysAgo === 1) {
+      otherDate = getMidnightAlignedDate(getDaysAgoDate(1)); // Yesterday
+    } else {
+      const targetDate = getDaysAgoDate(daysAgo);
+
+      // Filter available dates to find the closest one to the target
+      const availableDates = Object.keys(statisticHistory)
+        .map(dateKey => new Date(dateKey))
+        .filter(date => {
+          // Convert date back to the correct format for statisticHistory lookup
+          const formattedDate = formatDateMinimal(date);
+          const statsForDate = statisticHistory[formattedDate];
+          const hasStat = statsForDate && statType in statsForDate;
+
+          // Only consider past dates with the required statType
+          const isPast = date.getTime() < new Date().getTime();
+          return hasStat && isPast;
+        });
+
+      // If no valid dates are found, return undefined
+      if (availableDates.length === 0) {
+        return undefined;
+      }
+
+      // Find the closest date from the filtered available dates
+      otherDate = availableDates.reduce((closestDate, currentDate) => {
+        const currentDiff = Math.abs(currentDate.getTime() - targetDate.getTime());
+        const closestDiff = Math.abs(closestDate.getTime() - targetDate.getTime());
+        return currentDiff < closestDiff ? currentDate : closestDate;
+      }, availableDates[0]); // Start with the first available date
+    }
+
+    // Ensure todayStats exists and contains the statType
+    if (!todayStats || !getValueFromHistory(todayStats, statType)) {
+      return undefined;
+    }
+
+    const otherStats = statisticHistory[formatDateMinimal(otherDate)]; // This is now validated
+
+    // Ensure otherStats exists and contains the statType
+    if (!otherStats || !getValueFromHistory(otherStats, statType)) {
+      return undefined;
+    }
+
+    const statToday = getValueFromHistory(todayStats, statType);
+    const statOther = getValueFromHistory(otherStats, statType);
+
+    if (statToday === undefined || statOther === undefined) {
+      return undefined;
+    }
+    return (statToday - statOther) * (!isNegativeChange ? 1 : -1);
+  };
+
+  const getStatisticChanges = (daysAgo: number): PlayerHistory => {
+    return {
+      rank: getStatisticChange("rank", true, daysAgo),
+      countryRank: getStatisticChange("countryRank", true, daysAgo),
+      pp: getStatisticChange("pp", false, daysAgo),
+      replaysWatched: getStatisticChange("replaysWatched", false, daysAgo),
+      accuracy: {
+        averageRankedAccuracy: getStatisticChange("accuracy.averageRankedAccuracy", false, daysAgo),
+      },
+      score: {
+        totalScore: getStatisticChange("score.totalScore", false, daysAgo),
+        totalRankedScore: getStatisticChange("score.totalRankedScore", false, daysAgo),
+      },
+      scores: {
+        totalScores: getStatisticChange("scores.totalScores", false, daysAgo),
+        totalRankedScores: getStatisticChange("scores.totalRankedScores", false, daysAgo),
+        rankedScores: getStatisticChange("scores.rankedScores", false, daysAgo),
+        unrankedScores: getStatisticChange("scores.unrankedScores", false, daysAgo),
+      },
+    };
+  };
+
+  return {
+    id: token.id,
+    name: token.name,
+    avatar: token.profilePicture,
+    country: token.country,
+    rank: token.rank,
+    countryRank: token.countryRank,
+    joinedDate: new Date(token.firstSeen),
+    bio: bio,
+    pp: token.pp,
+    statisticChange: {
+      daily: getStatisticChanges(1),
+      weekly: getStatisticChanges(7),
+      monthly: getStatisticChanges(30),
+    },
+    role: token.role == null ? undefined : token.role,
+    badges: badges,
+    statisticHistory: statisticHistory,
+    statistics: token.scoreStats,
+    rankPages: {
+      global: getPageFromRank(token.rank, 50),
+      country: getPageFromRank(token.countryRank, 50),
+    },
+    permissions: token.permissions,
+    banned: token.banned,
+    inactive: token.inactive,
+    isBeingTracked: isBeingTracked,
+  };
+}

projects/common/src/types/around-player.ts

@@ -0,0 +1 @@
+export type AroundPlayer = "global" | "country";

projects/common/src/types/backend/app-statistics.ts

@@ -0,0 +1,21 @@
+export type AppStatistics = {
+  /**
+   * The total amount of players being tracked.
+   */
+  trackedPlayers: number;
+
+  /**
+   * The total amount of ScoreSaber scores tracked.
+   */
+  trackedScores: number;
+
+  /**
+   * The total amount of additional data for scores being tracked.
+   */
+  additionalScoresData: number;
+
+  /**
+   * The amount of cached BeatSaver maps.
+   */
+  cachedBeatSaverMaps: number;
+};

projects/common/src/types/map-characteristic.ts

@@ -0,0 +1 @@
+export type MapCharacteristic = "Standard" | "Lawless";

projects/common/src/types/metadata.ts

@@ -0,0 +1,28 @@
+export class Metadata {
+  /**
+   * The amount of pages in the pagination
+   */
+  public readonly totalPages: number;
+
+  /**
+   * The total amount of items
+   */
+  public readonly totalItems: number;
+
+  /**
+   * The current page
+   */
+  public readonly page: number;
+
+  /**
+   * The amount of items per page
+   */
+  public readonly itemsPerPage: number;
+
+  constructor(totalPages: number, totalItems: number, page: number, itemsPerPage: number) {
+    this.totalPages = totalPages;
+    this.totalItems = totalItems;
+    this.page = page;
+    this.itemsPerPage = itemsPerPage;
+  }
+}

projects/common/src/types/token/beatleader/difficulty.ts

@@ -0,0 +1,30 @@
+import { BeatLeaderModifierToken } from "./modifier/modifiers";
+import { BeatLeaderModifierRatingToken } from "./modifier/modifier-rating";
+
+export type BeatLeaderDifficultyToken = {
+  id: number;
+  value: number;
+  mode: number;
+  difficultyName: string;
+  modeName: string;
+  status: number;
+  modifierValues: BeatLeaderModifierToken;
+  modifiersRating: BeatLeaderModifierRatingToken;
+  nominatedTime: number;
+  qualifiedTime: number;
+  rankedTime: number;
+  stars: number;
+  predictedAcc: number;
+  passRating: number;
+  accRating: number;
+  techRating: number;
+  type: number;
+  njs: number;
+  nps: number;
+  notes: number;
+  bombs: number;
+  walls: number;
+  maxScore: number;
+  duration: number;
+  requirements: number;
+};