Merge branch 'master' of https://git.fascinated.cc/Fascinated/scoresaber-reloadedv3

Reviewed-on: #87

.gitea/kubernetes/backend/deployment.yaml

@@ -31,4 +31,9 @@ spec:
               valueFrom:
                 secretKeyRef:
                   name: ssr-backend-secret
-                  key: MONGO_URI
+                  key: MONGO_URI
+            - name: DISCORD_BOT_TOKEN
+              valueFrom:
+                secretKeyRef:
+                  name: ssr-backend-secret
+                  key: DISCORD_BOT_TOKEN

.gitea/kubernetes/backend/ingress.yaml

@@ -24,3 +24,27 @@ spec:
           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

@@ -7,7 +7,8 @@ metadata:
   namespace: public-services
 spec:
   encryptedData:
-    MONGO_URI: AgCUTvItz+Z7ZwWJZuNmdYtNmXPLjxf+48wydwwewJ7AZshoVQSfTNTU+Cu09p6NC9EXCOwsPYQuAqor81puHh/LbYDhdFaGDXWXGg6R6ELPQkU4hDTvIiNyTdeNhn5tFNMdsqwkrsdxjrfMsH+wSHcxJpH1dTmhkEytdhElQmTVJxITtvQlxljR2i9vV87TqYp2ebaBqcj3bGX/pfGLqImOPFJMw8TZ8N1jOxEtLOS9RJJL2YnJP4WH4OQhC+FIb1gQ8N7SI2CMj5Mqt8sdxrGnPBznUGJDEED2Vv7uqRTt/4Kysfv9DN1FpyifiWjGx61tLjS9WfsBoF12JiUFEcpBhBsWHhPjBeyWd6N9LWflDCB47eTLQt/HbarRnjtFpD04jrhv7XXF8YzOtjQDhVqhRDUdybt7LjN4VGw8P4mXf7JinwV4G49orsb561yas5xSTtZgL0t0uI0OTH+AYsiyB8Q9jWlJmdKTCM0gFU19uV+fPKC6UWN9gHXX9p5KK7ZX10I2UnH3knqa/OCGFj96C6RGN4cQlErnhjCrmlyfdcFiET6vgIaYnCbv1IxwpzlooqtWfmXqpmFfshfPWPdGuEqGOBaPmFYNwXaXVKsigv8gKIbWTl+ZhEnAN51wDYVRGT36fh8KM98I1ZcaRJKYJcz8I7+MnmEUDG97boWDe0wi6dY+INnQErsxcJ9W37d3BmEB0o0PS0yKA4lJXXWByS6T8AUpUidHCgufglQIuDXo1nBqVPoSOQg0OAq/kn4zUvfbw2+l0aZKrm0UILd5ZwAuAciJ/x7XtvcGfrYEJUpN/1DC5qL4J8s=
+    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

.gitea/workflows/deploy-backend.yml

@@ -1,4 +1,4 @@
-name: "Deploy Backend"
+name: Deploy Backend
 
 on:
   workflow_dispatch:
@@ -8,57 +8,91 @@ on:
     paths:
       - projects/backend/**
       - projects/common/**
-      - .gitea/kubernetes/backend/**
       - .gitea/workflows/deploy-backend.yml
 
 jobs:
-  deploy:
-    runs-on: ubuntu-latest
+  docker:
+    strategy:
+      matrix:
+        arch: ["ubuntu-latest"]
+    runs-on: ${{ matrix.arch }}
+
+    # Steps to run
     steps:
-      - name: Checkout code
+      # Checkout the repo
+      - name: Checkout
         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
+          fetch-depth: 0
 
-      - name: Build Image
-        uses: docker/build-push-action@v6
+      # Deploy to Dokku
+      - name: Push to dokku
+        uses: dokku/github-action@master
         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 }}
+          git_remote_url: "ssh://dokku@51.158.63.74:22/ssr-backend"
+          ssh_private_key: ${{ secrets.SSH_PRIVATE_KEY }}
 
-      - 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 }}
+#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

@@ -1,4 +1,4 @@
-name: "Deploy Website"
+name: Deploy Website
 
 on:
   workflow_dispatch:
@@ -8,56 +8,91 @@ on:
     paths:
       - projects/website/**
       - projects/common/**
-      - .gitea/kubernetes/website/**
       - .gitea/workflows/deploy-website.yml
+      - bun.lockb
 
 jobs:
-  deploy:
-    runs-on: ubuntu-latest
+  docker:
+    strategy:
+      matrix:
+        arch: ["ubuntu-latest"]
+    runs-on: ${{ matrix.arch }}
+
+    # Steps to run
     steps:
-      - name: Checkout code
+      # Checkout the repo
+      - name: Checkout
         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
+          fetch-depth: 0
 
-      - name: Build Image
-        uses: docker/build-push-action@v6
+      # Deploy to Dokku
+      - name: Push to dokku
+        uses: dokku/github-action@master
         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 }}
+          git_remote_url: "ssh://dokku@51.158.63.74:22/ssr-website"
+          ssh_private_key: ${{ secrets.SSH_PRIVATE_KEY }}
 
-      - 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 }}
+#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/fix-bun-lock-file.yml

@@ -1,26 +0,0 @@
-name: Fix bun lock file
-
-on:
-  push:
-    paths:
-      - package.json
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install bun
-        uses: oven-sh/setup-bun@v2
-
-      - name: Install dependencies
-        run: bun install
-
-      - name: Commit bun lock file
-        run: |
-          git config --global user.email "helper@fascinated.cc"
-          git config --global user.name "Bun Fixer"
-          git add bun.lockb
-          git commit -m "Fix bun lock file"
-          git push

README.md

@@ -4,4 +4,4 @@ This is the 3rd re-code of this project. The first one was a mess, the second on
 
 ## meow
 
-meow
+meow

package.json

@@ -13,6 +13,7 @@
   "author": "fascinated7",
   "license": "MIT",
   "dependencies": {
-    "concurrently": "^9.0.1"
+    "concurrently": "^9.0.1",
+    "cross-env": "^7.0.3"
   }
 }

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/Dockerfile

@@ -1,4 +1,4 @@
-FROM oven/bun:1.1.30-alpine AS base
+FROM oven/bun:1.1.33-alpine AS base
 
 # Install dependencies
 FROM base AS depends
@@ -24,4 +24,11 @@ RUN bun --filter '@ssr/common' build
 # Copy the backend project
 COPY --from=depends /app/projects/backend ./projects/backend
 
-CMD ["bun", "run", "--filter", "backend", "start"]
+# Lint before starting
+RUN bun --filter 'backend' lint
+
+ARG PORT=8080
+ENV PORT $PORT
+EXPOSE $PORT
+
+CMD ["bun", "run", "--filter", "backend", "start"]

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

@@ -3,7 +3,8 @@
   "version": "1.0.0",
   "scripts": {
     "dev": "bun run --watch src/index.ts",
-    "start": "bun run src/index.ts"
+    "start": "bun run src/index.ts",
+    "lint": "eslint src/**/*.ts"
   },
   "dependencies": {
     "@bogeychan/elysia-etag": "^0.0.6",
@@ -13,13 +14,23 @@
     "@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",
-    "elysia-rate-limit": "^4.1.0",
-    "mongoose": "^8.7.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"

projects/backend/src/bot/bot.ts

@@ -0,0 +1,65 @@
+import { Client, MetadataStorage } from "discordx";
+import { ActivityType, EmbedBuilder } from "discord.js";
+import { Config } from "@ssr/common/config";
+
+export const guildId = "1295984874942894100";
+export enum DiscordChannels {
+  trackedPlayerLogs = "1295985197262569512",
+  numberOneFeed = "1295988063817830430",
+  backendLogs = "1296524935237468250",
+}
+
+const client = new Client({
+  intents: ["Guilds", "GuildMessages"],
+  presence: {
+    status: "online",
+
+    activities: [
+      {
+        name: "scores...",
+        type: ActivityType.Watching,
+        url: "https://ssr.fascinated.cc",
+      },
+    ],
+  },
+});
+
+client.once("ready", () => {
+  console.log("Discord bot ready!");
+});
+
+export async function initDiscordBot() {
+  console.log("Initializing discord bot...");
+
+  // We will now build our application to load all the commands/events for both bots.
+  MetadataStorage.instance.build().then(async () => {
+    // Setup slash commands
+    client.once("ready", async () => {
+      await client.initApplicationCommands();
+      console.log(client.applicationCommands);
+    });
+    client.on("interactionCreate", interaction => {
+      client.executeInteraction(interaction);
+    });
+
+    // Login
+    await client.login(Config.discordBotToken!);
+  });
+}
+
+/**
+ * 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) {
+  try {
+    const channel = await client.channels.fetch(channelId);
+    if (channel != undefined && channel.isSendable()) {
+      channel.send({ embeds: [message] });
+    }
+  } catch {
+    /* empty */
+  }
+}

projects/backend/src/bot/command/refresh-player-scores-command.ts

@@ -0,0 +1,20 @@
+import { Discord, Guild, Slash } from "discordx";
+import { CommandInteraction } from "discord.js";
+import { PlayerService } from "../../service/player.service";
+import { guildId } from "../bot";
+
+@Discord()
+export class RefreshPlayerScoresCommand {
+  @Guild(guildId)
+  @Slash({
+    description: "Refreshes scores for all tracked players",
+    name: "refresh-player-scores",
+    defaultMemberPermissions: ["Administrator"],
+  })
+  hello(interaction: CommandInteraction) {
+    interaction.reply("Updating player scores...").then(async response => {
+      await PlayerService.refreshPlayerScores();
+      await response.edit("Done!");
+    });
+  }
+}

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

@@ -1,9 +1,9 @@
 /**
  * Gets the app version.
  */
-export function getAppVersion() {
+export async function getAppVersion() {
   if (!process.env.APP_VERSION) {
-    const packageJson = require("../../package.json");
+    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 "@ssr/common/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/config.ts

@@ -1,3 +0,0 @@
-export const Config = {
-  mongoUri: process.env.MONGO_URI,
-}

projects/backend/src/common/embds.ts

@@ -0,0 +1,37 @@
+import ScoreSaberPlayerToken from "@ssr/common/types/token/scoresaber/score-saber-player-token";
+import { DiscordChannels, logToChannel } from "../bot/bot";
+import { EmbedBuilder } from "discord.js";
+import { formatPp } from "@ssr/common/utils/number-utils";
+
+/**
+ * Logs that a new player is being tracked
+ *
+ * @param player the player being tracked
+ */
+export async function logNewTrackedPlayer(player: ScoreSaberPlayerToken) {
+  await logToChannel(
+    DiscordChannels.trackedPlayerLogs,
+    new EmbedBuilder()
+      .setTitle("New Player Tracked")
+      .setDescription(`https://ssr.fascinated.cc/player/${player.id}`)
+      .addFields([
+        {
+          name: "Username",
+          value: player.name,
+          inline: true,
+        },
+        {
+          name: "ID",
+          value: player.id,
+          inline: true,
+        },
+        {
+          name: "PP",
+          value: formatPp(player.pp) + "pp",
+          inline: true,
+        },
+      ])
+      .setThumbnail(player.profilePicture)
+      .setColor("#00ff00")
+  );
+}

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

@@ -1,13 +1,26 @@
 import { Controller, Get } from "elysia-decorators";
-import { getAppVersion } from "../common/app-utils";
+import { getAppVersion } from "../common/app.util";
+import { AppService } from "../service/app.service";
 
 @Controller()
 export default class AppController {
   @Get("/")
-  public index() {
+  public async index() {
     return {
       app: "backend",
-      version: getAppVersion(),
+      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

@@ -1,29 +1,38 @@
 import { Controller, Get } from "elysia-decorators";
 import { PlayerService } from "../service/player.service";
 import { t } from "elysia";
-import { PlayerHistory } from "@ssr/common/types/player/player-history";
-import { PlayerTrackedSince } from "@ssr/common/types/player/player-tracked-since";
+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", {
+  @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 },
+    params: { id, days },
     query: { createIfMissing },
   }: {
-    params: { id: string };
+    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(50) };
+    return { statistics: player.getHistoryPreviousDays(days) };
   }
 
   @Get("/tracked/:id", {
@@ -51,4 +60,21 @@ export default class PlayerController {
       };
     }
   }
+
+  @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,104 @@
+import { Controller, Get } from "elysia-decorators";
+import { t } from "elysia";
+import { Leaderboards } from "@ssr/common/leaderboard";
+import { TopScoresResponse } from "@ssr/common/response/top-scores-response";
+import { ScoreService } from "../service/score.service";
+import { Timeframe } from "@ssr/common/timeframe";
+
+@Controller("/scores")
+export default class ScoresController {
+  @Get("/player/:leaderboard/:id/:page/:sort", {
+    config: {},
+    params: t.Object({
+      leaderboard: t.String({ required: true }),
+      id: t.String({ required: true }),
+      page: t.Number({ required: true }),
+      sort: t.String({ required: true }),
+    }),
+    query: t.Object({
+      search: t.Optional(t.String()),
+    }),
+  })
+  public async getScores({
+    params: { leaderboard, id, page, sort },
+    query: { search },
+  }: {
+    params: {
+      leaderboard: Leaderboards;
+      id: string;
+      page: number;
+      sort: string;
+    };
+    query: { search?: string };
+  }): Promise<unknown> {
+    return await ScoreService.getPlayerScores(leaderboard, id, page, sort, 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);
+  }
+
+  @Get("/history/:playerId/:leaderboardId/:page", {
+    config: {},
+    params: t.Object({
+      playerId: t.String({ required: true }),
+      leaderboardId: t.String({ required: true }),
+      page: t.Number({ required: true }),
+    }),
+  })
+  public async getScoreHistory({
+    params: { playerId, leaderboardId, page },
+  }: {
+    params: {
+      playerId: string;
+      leaderboardId: string;
+      page: number;
+    };
+    query: { search?: string };
+  }): Promise<unknown> {
+    return (await ScoreService.getScoreHistory(playerId, leaderboardId, page)).toJSON();
+  }
+
+  @Get("/top", {
+    config: {},
+    query: t.Object({
+      limit: t.Number({ required: true }),
+      timeframe: t.String({ required: true }),
+    }),
+  })
+  public async getTopScores({
+    query: { limit, timeframe },
+  }: {
+    query: { limit: number; timeframe: Timeframe };
+  }): Promise<TopScoresResponse> {
+    if (limit <= 0) {
+      limit = 1;
+    } else if (limit > 100) {
+      limit = 100;
+    }
+
+    const scores = await ScoreService.getTopScores(limit, timeframe);
+    return {
+      scores,
+      timeframe,
+      limit,
+    };
+  }
+}

projects/backend/src/index.ts

@@ -3,28 +3,86 @@ import cors from "@elysiajs/cors";
 import { decorators } from "elysia-decorators";
 import { logger } from "@tqman/nice-logger";
 import { swagger } from "@elysiajs/swagger";
-import { rateLimit } from "elysia-rate-limit";
-import { RateLimitError } from "./error/rate-limit-error";
 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 { Config } from "./common/config";
-import { setLogLevel } from "@typegoose/typegoose";
 import PlayerController from "./controller/player.controller";
 import { PlayerService } from "./service/player.service";
+import { cron } from "@elysiajs/cron";
+import { 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 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";
 
 // Load .env file
 dotenv.config({
-  logLevel: "success",
+  logLevel: (await Bun.file(".env").exists()) ? "success" : "warn",
   path: ".env",
   override: true,
 });
 
+// Connect to Mongo
 await mongoose.connect(Config.mongoUri!); // Connect to MongoDB
-setLogLevel("DEBUG");
+
+// 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: "0 1 * * *", // Every day at 00:01
+    timezone: "Europe/London", // UTC time
+    protect: true,
+    run: async () => {
+      await PlayerService.updatePlayerStatistics();
+    },
+  })
+);
+app.use(
+  cron({
+    name: "player-scores-tracker-cron",
+    pattern: "0 4 * * *", // Every day at 04:00
+    timezone: "Europe/London", // UTC time
+    protect: true,
+    run: async () => {
+      await PlayerService.refreshPlayerScores();
+    },
+  })
+);
 
 /**
  * Custom error handler
@@ -35,7 +93,7 @@ app.onError({ as: "global" }, ({ code, error }) => {
     return error.all;
   }
 
-  let status = "status" in error ? error.status : undefined;
+  const status = "status" in error ? error.status : undefined;
   return {
     ...((status && { statusCode: status }) || { status: code }),
     ...(error.message != code && { message: error.message }),
@@ -58,27 +116,11 @@ app.use(cors());
  */
 app.use(
   logger({
+    enabled: true,
     mode: "combined",
   })
 );
 
-/**
- * Rate limit (100 requests per minute)
- */
-app.use(
-  rateLimit({
-    scoping: "global",
-    duration: 60 * 1000,
-    max: 100,
-    skip: request => {
-      let [_, path] = request.url.split("/"); // Get the url parts
-      path === "" || (path === undefined && (path = "/")); // If we're on /, the path is undefined, so we set it to /
-      return path === "/"; // ignore all requests to /
-    },
-    errorResponse: new RateLimitError("Too many requests, please try again later"),
-  })
-);
-
 /**
  * Security settings
  */
@@ -95,22 +137,40 @@ app.use(
  */
 app.use(
   decorators({
-    controllers: [AppController, PlayerController],
+    controllers: [AppController, PlayerController, ImageController, ScoresController, LeaderboardController],
   })
 );
 
 /**
  * Swagger Documentation
  */
-app.use(swagger());
+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(() => {
+app.onStart(async () => {
   console.log("Listening on port http://localhost:8080");
+  if (isProduction()) {
+    await initDiscordBot();
+  }
 });
 
-/**
- * Start cronjobs
- */
-PlayerService.initCronjobs();
-
-app.listen(8080);
+app.listen({
+  port: 8080,
+  idleTimeout: 120, // 2 minutes
+});

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

@@ -0,0 +1,38 @@
+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";
+import { ScoreSaberLeaderboardModel } from "@ssr/common/model/leaderboard/impl/scoresaber-leaderboard";
+import { SSRCache } from "@ssr/common/cache";
+
+const statisticsCache = new SSRCache({
+  ttl: 120 * 1000, // 2 minutes
+});
+
+export class AppService {
+  /**
+   * Gets the app statistics.
+   */
+  public static async getAppStatistics(): Promise<AppStatistics> {
+    if (statisticsCache.has("app-statistics")) {
+      return statisticsCache.get<AppStatistics>("app-statistics")!;
+    }
+
+    const trackedPlayers = await PlayerModel.countDocuments();
+    const trackedScores = await ScoreSaberScoreModel.countDocuments();
+    const additionalScoresData = await AdditionalScoreDataModel.countDocuments();
+    const cachedBeatSaverMaps = await BeatSaverMapModel.countDocuments();
+    const cachedScoreSaberLeaderboards = await ScoreSaberLeaderboardModel.countDocuments();
+
+    const response = {
+      trackedPlayers,
+      trackedScores,
+      additionalScoresData,
+      cachedBeatSaverMaps,
+      cachedScoreSaberLeaderboards,
+    };
+    statisticsCache.set("app-statistics", response);
+    return response;
+  }
+}

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,218 @@
+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 { StarIcon } from "../../components/star-icon";
+import { GlobeIcon } from "../../components/globe-icon";
+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";
+import LeaderboardService from "./leaderboard.service";
+import ScoreSaberLeaderboard from "@ssr/common/model/leaderboard/impl/scoresaber-leaderboard";
+
+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 response = await LeaderboardService.getLeaderboard<ScoreSaberLeaderboard>("scoresaber", id);
+    if (!response) {
+      return undefined;
+    }
+    const { leaderboard } = response;
+
+    const ranked = leaderboard.stars > 0;
+
+    return new ImageResponse(
+      (
+        <ImageService.BaseImage>
+          {/* Leaderboard Cover Image */}
+          <img src={leaderboard.songArt} 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" : "")}>{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,96 @@
+import { Leaderboards } from "@ssr/common/leaderboard";
+import { scoresaberService } from "@ssr/common/service/impl/scoresaber";
+import { LeaderboardResponse } from "@ssr/common/response/leaderboard-response";
+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";
+import {
+  ScoreSaberLeaderboard,
+  ScoreSaberLeaderboardModel,
+} from "@ssr/common/model/leaderboard/impl/scoresaber-leaderboard";
+import Leaderboard from "@ssr/common/model/leaderboard/leaderboard";
+
+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> {
+    switch (leaderboard) {
+      case "scoresaber": {
+        return (await scoresaberService.lookupLeaderboard(id)) as T;
+      }
+      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;
+
+    const now = new Date();
+    switch (leaderboardName) {
+      case "scoresaber": {
+        let foundLeaderboard = false;
+        const cachedLeaderboard = await ScoreSaberLeaderboardModel.findById(id);
+        if (cachedLeaderboard != null) {
+          leaderboard = cachedLeaderboard.toObject() as unknown as ScoreSaberLeaderboard;
+          if (
+            leaderboard &&
+            (leaderboard.ranked || // Never refresh ranked leaderboards (it will get refreshed every night)
+              leaderboard.lastRefreshed == undefined || // Refresh if it has never been refreshed
+              now.getTime() - leaderboard.lastRefreshed.getTime() > 1000 * 60 * 60 * 24) // Refresh every day
+          ) {
+            foundLeaderboard = true;
+          }
+        }
+
+        if (!foundLeaderboard) {
+          const leaderboardToken = await LeaderboardService.getLeaderboardToken<ScoreSaberLeaderboardToken>(
+            leaderboardName,
+            id
+          );
+          if (leaderboardToken == undefined) {
+            throw new NotFoundError(`Leaderboard not found for "${id}"`);
+          }
+
+          leaderboard = getScoreSaberLeaderboardFromToken(leaderboardToken);
+          leaderboard.lastRefreshed = new Date();
+
+          await ScoreSaberLeaderboardModel.findOneAndUpdate({ _id: id }, leaderboard, {
+            upsert: true,
+            new: true,
+            setDefaultsOnInsert: true,
+          });
+        }
+        if (leaderboard == undefined) {
+          throw new NotFoundError(`Leaderboard not found for "${id}"`);
+        }
+
+        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

@@ -1,64 +1,82 @@
-import { PlayerDocument, PlayerModel } from "../model/player";
-import { NotFoundError } from "../error/not-found-error";
-import { cron } from "@elysiajs/cron";
-import { app } from "../index";
+import { PlayerDocument, PlayerModel } from "@ssr/common/model/player";
+import { NotFoundError } from "@ssr/common/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 { InternalServerError } from "@ssr/common/error/internal-server-error";
+import { delay, getPageFromRank, isProduction } from "@ssr/common/utils/utils";
+import { AroundPlayer } from "@ssr/common/types/around-player";
+import { ScoreSort } from "@ssr/common/score/score-sort";
+import { getScoreSaberLeaderboardFromToken } from "@ssr/common/token-creators";
+import { ScoreService } from "./score.service";
+import { logNewTrackedPlayer } from "../common/embds";
+
+const SCORESABER_REQUEST_COOLDOWN = 60_000 / 250; // 250 requests per minute
+const accountCreationLock: { [id: string]: Promise<PlayerDocument> } = {};
 
 export class PlayerService {
-  /**
-   * Initialize the cron jobs
-   */
-  public static initCronjobs() {
-    app.use(
-      cron({
-        name: "player-statistics-tracker-cron",
-        pattern: "0 1 * * *", // Every day at 00:01 (midnight)
-        run: async () => {
-          const players: PlayerDocument[] = await PlayerModel.find({});
-          for (const player of players) {
-            await PlayerService.trackScoreSaberPlayer(getMidnightAlignedDate(new Date()), player);
-          }
-        },
-      })
-    );
-  }
-
-  /**
-   * Get a player from the database.
-   *
-   * @param id the player to fetch
-   * @param create if true, create the player if it doesn't exist
-   * @returns the player
-   * @throws NotFoundError if the player is not found
-   */
-  public static async getPlayer(id: string, create: boolean = false): Promise<PlayerDocument> {
-    console.log(`Fetching player "${id}"...`);
-    let player: PlayerDocument | null = await PlayerModel.findById(id);
-    if (player === null && !create) {
-      console.log(`Player "${id}" not found.`);
-      throw new NotFoundError(`Player "${id}" not found`);
+  public static async getPlayer(
+    id: string,
+    create: boolean = false,
+    playerToken?: ScoreSaberPlayerToken
+  ): Promise<PlayerDocument> {
+    // Wait for the existing lock if it's in progress
+    if (accountCreationLock[id] !== undefined) {
+      await accountCreationLock[id];
     }
+
+    let player: PlayerDocument | null = await PlayerModel.findById(id);
+
     if (player === null) {
-      const playerToken = await scoresaberService.lookupPlayer(id);
-      if (playerToken === undefined) {
+      if (!create) {
         throw new NotFoundError(`Player "${id}" not found`);
       }
 
-      console.log(`Creating player "${id}"...`);
-      player = (await PlayerModel.create({ _id: id })) as any;
-      if (player === null) {
-        throw new InternalServerError(`Failed to create player document for "${id}"`);
+      playerToken = playerToken || (await scoresaberService.lookupPlayer(id));
+
+      if (!playerToken) {
+        throw new NotFoundError(`Player "${id}" not found`);
+      }
+
+      // Create a new lock promise and assign it
+      accountCreationLock[id] = (async () => {
+        let newPlayer: PlayerDocument;
+        try {
+          console.log(`Creating player "${id}"...`);
+          newPlayer = (await PlayerModel.create({ _id: id })) as PlayerDocument;
+          newPlayer.trackedSince = new Date();
+          await newPlayer.save();
+
+          await this.seedPlayerHistory(newPlayer, playerToken);
+          await this.refreshAllPlayerScores(newPlayer);
+
+          // Notify in production
+          if (isProduction()) {
+            await logNewTrackedPlayer(playerToken);
+          }
+        } catch (err) {
+          console.log(`Failed to create player document for "${id}"`, err);
+          throw new InternalServerError(`Failed to create player document for "${id}"`);
+        } finally {
+          // Ensure the lock is always removed
+          delete accountCreationLock[id];
+        }
+
+        return newPlayer;
+      })();
+
+      // Wait for the player creation to complete
+      player = await accountCreationLock[id];
+
+      // Update player name
+      if (player.name !== playerToken.name) {
+        player.name = playerToken.name;
+        await player.save();
       }
-      player.trackedSince = new Date();
-      await this.seedPlayerHistory(player, playerToken);
-      console.log(`Created player "${id}".`);
-    } else {
-      console.log(`Found player "${id}".`);
     }
-    return player;
+
+    // Ensure that the player is now of type PlayerDocument
+    return player as PlayerDocument;
   }
 
   /**
@@ -75,26 +93,36 @@ export class PlayerService {
     });
     playerRankHistory.push(playerToken.rank);
 
-    let daysAgo = 1; // Start from yesterday
+    let daysAgo = 0; // Start from today
     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 dateToday the date to track
    * @param foundPlayer the player to track
+   * @param playerToken an optional player token
    */
-  public static async trackScoreSaberPlayer(dateToday: Date, foundPlayer: PlayerDocument) {
-    const player = await scoresaberService.lookupPlayer(foundPlayer.id);
+  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;
@@ -106,7 +134,7 @@ export class PlayerService {
 
     // Seed the history with ScoreSaber data if no history exists
     if (foundPlayer.getDaysTracked() === 0) {
-      await this.seedPlayerHistory(foundPlayer, player);
+      await this.seedPlayerHistory(foundPlayer.id, player);
     }
 
     // Update current day's statistics
@@ -114,15 +142,230 @@ export class PlayerService {
     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);
+  }
+
+  /**
+   * Refreshes all the players scores.
+   *
+   * @param player the player to refresh
+   */
+  public static async refreshAllPlayerScores(player: PlayerDocument) {
+    await this.refreshPlayerScoreSaberScores(player);
+  }
+
+  /**
+   * Ensures that all the players scores from the
+   * ScoreSaber API are up-to-date.
+   *
+   * @param player the player to refresh
+   * @private
+   */
+  private static async refreshPlayerScoreSaberScores(player: PlayerDocument) {
+    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) {
+        console.warn(`Failed to fetch scores for ${player.id} on page ${page}.`);
+        break;
+      }
+
+      let missingScores = 0;
+      for (const score of scoresPage.playerScores) {
+        const leaderboard = getScoreSaberLeaderboardFromToken(score.leaderboard);
+        const scoreSaberScore = await ScoreService.getScoreSaberScore(
+          player.id,
+          leaderboard.id + "",
+          leaderboard.difficulty.difficulty,
+          leaderboard.difficulty.characteristic,
+          score.score.baseScore
+        );
+
+        if (scoreSaberScore == null) {
+          missingScores++;
+        }
+        await ScoreService.trackScoreSaberScore(score.score, score.leaderboard, player.id);
+      }
+
+      // Stop paginating if no scores are missing OR if player has seededScores marked true
+      if ((missingScores === 0 && player.seededScores) || page >= Math.ceil(scoresPage.metadata.total / 100)) {
+        hasMorePages = false;
+      }
+
+      page++;
+      await delay(SCORESABER_REQUEST_COOLDOWN); // Cooldown between page requests
+    }
+
+    // Mark player as seeded
+    player.seededScores = true;
+    await player.save();
+
+    console.log(`Finished refreshing scores for ${player.id}, total pages refreshed: ${page - 1}.`);
+  }
+
+  /**
+   * Ensures all player scores are up-to-date.
+   */
+  public static async refreshPlayerScores() {
+    console.log(`Refreshing player score data...`);
+
+    const players = await PlayerModel.find({});
+    console.log(`Found ${players.length} players to refresh.`);
+
+    for (const player of players) {
+      await this.refreshAllPlayerScores(player);
+      await delay(SCORESABER_REQUEST_COOLDOWN); // Cooldown between players
+    }
+  }
+
+  /**
+   * Updates the player statistics for all players.
+   */
+  public static async updatePlayerStatistics() {
+    const pages = 20; // top 1000 players
+
+    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(SCORESABER_REQUEST_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(SCORESABER_REQUEST_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(SCORESABER_REQUEST_COOLDOWN);
+    }
+    console.log("Finished tracking player statistics.");
+  }
 }

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

@@ -0,0 +1,714 @@
+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 BeatSaverService from "./beatsaver.service";
+import { scoresaberService } from "@ssr/common/service/impl/scoresaber";
+import { ScoreSort } from "@ssr/common/score/score-sort";
+import { Leaderboards } from "@ssr/common/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 { ScoreType } from "@ssr/common/model/score/score";
+import { getScoreSaberLeaderboardFromToken, getScoreSaberScoreFromToken } from "@ssr/common/token-creators";
+import {
+  ScoreSaberPreviousScore,
+  ScoreSaberScore,
+  ScoreSaberScoreModel,
+} from "@ssr/common/model/score/impl/scoresaber-score";
+import ScoreSaberScoreToken from "@ssr/common/types/token/scoresaber/score-saber-score-token";
+import ScoreSaberLeaderboardToken from "@ssr/common/types/token/scoresaber/score-saber-leaderboard-token";
+import { MapDifficulty } from "@ssr/common/score/map-difficulty";
+import { MapCharacteristic } from "@ssr/common/types/map-characteristic";
+import { Page, Pagination } from "@ssr/common/pagination";
+import ScoreSaberLeaderboard from "@ssr/common/model/leaderboard/impl/scoresaber-leaderboard";
+import Leaderboard from "@ssr/common/model/leaderboard/leaderboard";
+import { Timeframe } from "@ssr/common/timeframe";
+import { getDaysAgoDate } from "@ssr/common/utils/time-utils";
+import { PlayerService } from "./player.service";
+
+const playerScoresCache = new SSRCache({
+  ttl: 1000 * 60, // 1 minute
+});
+
+const leaderboardScoresCache = new SSRCache({
+  ttl: 1000 * 60, // 1 minute
+});
+
+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);
+    player.markModified("statisticHistory");
+    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 = (scoreToken.leaderboardPlayerInfo && scoreToken.leaderboardPlayerInfo.id) || playerId;
+    if (!playerId) {
+      console.error(`Player ID is undefined, unable to track score: ${scoreToken.id}`);
+      return;
+    }
+
+    const playerName = (scoreToken.leaderboardPlayerInfo && scoreToken.leaderboardPlayerInfo.name) || "Unknown";
+
+    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;
+    }
+
+    // Update player name
+    if (playerName !== "Unknown") {
+      player.name = playerName;
+      await player.save();
+    }
+
+    // The score has already been tracked, so ignore it.
+    if (
+      (await this.getScoreSaberScore(
+        playerId,
+        leaderboard.id + "",
+        leaderboard.difficulty.difficulty,
+        leaderboard.difficulty.characteristic,
+        score.score
+      )) !== null
+    ) {
+      console.log(
+        `ScoreSaber score already tracked for "${playerName}"(${playerId}), difficulty: ${score.difficulty}, score: ${score.score}, leaderboard: ${leaderboard.id}, ignoring...`
+      );
+      return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    delete score.playerInfo;
+
+    await ScoreSaberScoreModel.create(score);
+    console.log(
+      `Tracked ScoreSaber score for "${playerName}"(${playerId}), difficulty: ${score.difficulty}, score: ${score.score}, pp: ${score.pp.toFixed(2)}pp, leaderboard: ${leaderboard.id}`
+    );
+  }
+
+  /**
+   * 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 top tracked scores.
+   *
+   * @param amount the amount of scores to get
+   * @param timeframe the timeframe to filter by
+   * @returns the top scores
+   */
+  public static async getTopScores(amount: number = 100, timeframe: Timeframe) {
+    console.log(`Getting top scores for timeframe: ${timeframe}, limit: ${amount}...`);
+    const before = Date.now();
+
+    let daysAgo = -1;
+    if (timeframe === "daily") {
+      daysAgo = 1;
+    } else if (timeframe === "weekly") {
+      daysAgo = 8;
+    } else if (timeframe === "monthly") {
+      daysAgo = 31;
+    }
+    const date: Date = daysAgo == -1 ? new Date(0) : getDaysAgoDate(daysAgo);
+    const foundScores = await ScoreSaberScoreModel.aggregate([
+      { $match: { timestamp: { $gte: date } } },
+      {
+        $group: {
+          _id: { leaderboardId: "$leaderboardId", playerId: "$playerId" },
+          score: { $first: "$$ROOT" },
+        },
+      },
+      { $sort: { "score.pp": -1 } },
+      { $limit: amount },
+    ]);
+
+    const scores: PlayerScore<ScoreSaberScore, ScoreSaberLeaderboard>[] = [];
+    for (const { score: scoreData } of foundScores) {
+      const score = new ScoreSaberScoreModel(scoreData).toObject() as ScoreSaberScore;
+      const leaderboardResponse = await LeaderboardService.getLeaderboard<ScoreSaberLeaderboard>(
+        "scoresaber",
+        score.leaderboardId + ""
+      );
+      if (!leaderboardResponse) {
+        continue;
+      }
+      const { leaderboard, beatsaver } = leaderboardResponse;
+
+      try {
+        const player = await PlayerService.getPlayer(score.playerId);
+        if (player !== undefined) {
+          score.playerInfo = {
+            id: player.id,
+            name: player.name,
+          };
+        }
+      } catch {
+        score.playerInfo = {
+          id: score.playerId,
+        };
+      }
+
+      const [additionalData, previousScore] = await Promise.all([
+        this.getAdditionalScoreData(
+          score.playerId,
+          leaderboard.songHash,
+          `${leaderboard.difficulty.difficulty}-${leaderboard.difficulty.characteristic}`,
+          score.score
+        ),
+        this.getPreviousScore(score.playerId, leaderboard.id + "", score.timestamp),
+      ]);
+      if (additionalData) {
+        score.additionalData = additionalData;
+      }
+      if (previousScore) {
+        score.previousScore = previousScore;
+      }
+
+      scores.push({
+        score: score,
+        leaderboard: leaderboard,
+        beatSaver: beatsaver,
+      });
+    }
+    console.log(`Got ${scores.length} scores in ${Date.now() - before}ms (timeframe: ${timeframe}, limit: ${amount})`);
+    return scores;
+  }
+
+  /**
+   * 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 a ScoreSaber score.
+   *
+   * @param playerId the player who set the score
+   * @param leaderboardId the leaderboard id the score was set on
+   * @param difficulty the difficulty played
+   * @param characteristic the characteristic played
+   * @param score the score of the score set
+   */
+  public static async getScoreSaberScore(
+    playerId: string,
+    leaderboardId: string,
+    difficulty: MapDifficulty,
+    characteristic: MapCharacteristic,
+    score: number
+  ) {
+    return ScoreSaberScoreModel.findOne({
+      playerId: playerId,
+      leaderboardId: leaderboardId,
+      difficulty: difficulty,
+      characteristic: characteristic,
+      score: score,
+    });
+  }
+
+  public static async getPlayerScores(
+    leaderboardName: Leaderboards,
+    playerId: string,
+    page: number,
+    sort: string,
+    search?: string
+  ): Promise<PlayerScoresResponse<unknown, unknown> | undefined> {
+    return fetchWithCache(
+      playerScoresCache,
+      `player-scores-${leaderboardName}-${playerId}-${page}-${sort}-${search}`,
+      async () => {
+        const scores: PlayerScore<unknown, unknown>[] = [];
+        let metadata: Metadata = new Metadata(0, 0, 0, 0); // Default values
+
+        switch (leaderboardName) {
+          case "scoresaber": {
+            const leaderboardScores = await scoresaberService.lookupPlayerScores({
+              playerId,
+              page,
+              sort: sort as ScoreSort,
+              search,
+            });
+            if (leaderboardScores == undefined) {
+              break;
+            }
+
+            metadata = new Metadata(
+              Math.ceil(leaderboardScores.metadata.total / leaderboardScores.metadata.itemsPerPage),
+              leaderboardScores.metadata.total,
+              leaderboardScores.metadata.page,
+              leaderboardScores.metadata.itemsPerPage
+            );
+
+            const scorePromises = leaderboardScores.playerScores.map(async token => {
+              const leaderboard = getScoreSaberLeaderboardFromToken(token.leaderboard);
+              if (!leaderboard) return undefined;
+
+              const score = getScoreSaberScoreFromToken(token.score, leaderboard, playerId);
+              if (!score) return undefined;
+
+              // Fetch additional data, previous score, and BeatSaver map concurrently
+              const [additionalData, previousScore, beatSaverMap] = await Promise.all([
+                this.getAdditionalScoreData(
+                  playerId,
+                  leaderboard.songHash,
+                  `${leaderboard.difficulty.difficulty}-${leaderboard.difficulty.characteristic}`,
+                  score.score
+                ),
+                this.getPreviousScore(playerId, leaderboard.id + "", score.timestamp),
+                BeatSaverService.getMap(leaderboard.songHash),
+              ]);
+
+              if (additionalData) {
+                score.additionalData = additionalData;
+              }
+              if (previousScore) {
+                score.previousScore = previousScore;
+              }
+
+              return {
+                score: score,
+                leaderboard: leaderboard,
+                beatSaver: beatSaverMap,
+              } as PlayerScore<ScoreSaberScore, ScoreSaberLeaderboard>;
+            });
+
+            const resolvedScores = (await Promise.all(scorePromises)).filter(
+              (s): s is PlayerScore<ScoreSaberScore, ScoreSaberLeaderboard> => s !== undefined
+            );
+            scores.push(...resolvedScores);
+            break;
+          }
+          default: {
+            throw new NotFoundError(`Leaderboard "${leaderboardName}" not found`);
+          }
+        }
+
+        return {
+          scores: scores,
+          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,
+        };
+      }
+    );
+  }
+
+  /**
+   * Gets the player's score history for a map.
+   *
+   * @param playerId the player's id to get the previous scores for
+   * @param leaderboardId the leaderboard to get the previous scores on
+   * @param page the page to get
+   */
+  public static async getScoreHistory(
+    playerId: string,
+    leaderboardId: string,
+    page: number
+  ): Promise<Page<PlayerScore<ScoreSaberScore, ScoreSaberLeaderboard>>> {
+    const scores = await ScoreSaberScoreModel.find({ playerId: playerId, leaderboardId: leaderboardId })
+      .sort({ timestamp: -1 })
+      .skip(1);
+    if (scores == null || scores.length == 0) {
+      throw new NotFoundError(`No previous scores found for ${playerId} in ${leaderboardId}`);
+    }
+
+    return new Pagination<PlayerScore<ScoreSaberScore, ScoreSaberLeaderboard>>()
+      .setItemsPerPage(8)
+      .setTotalItems(scores.length)
+      .getPage(page, async () => {
+        const toReturn: PlayerScore<ScoreSaberScore, ScoreSaberLeaderboard>[] = [];
+        for (const score of scores) {
+          const leaderboardResponse = await LeaderboardService.getLeaderboard<ScoreSaberLeaderboard>(
+            "scoresaber",
+            leaderboardId
+          );
+          if (leaderboardResponse == undefined) {
+            throw new NotFoundError(`Leaderboard "${leaderboardId}" not found`);
+          }
+          const { leaderboard, beatsaver } = leaderboardResponse;
+
+          const additionalData = await this.getAdditionalScoreData(
+            playerId,
+            leaderboard.songHash,
+            `${leaderboard.difficulty.difficulty}-${leaderboard.difficulty.characteristic}`,
+            score.score
+          );
+          if (additionalData !== undefined) {
+            score.additionalData = additionalData;
+          }
+          const previousScore = await this.getPreviousScore(playerId, leaderboardId, score.timestamp);
+          if (previousScore !== undefined) {
+            score.previousScore = previousScore;
+          }
+
+          toReturn.push({
+            score: score as unknown as ScoreSaberScore,
+            leaderboard: leaderboard,
+            beatSaver: beatsaver,
+          });
+        }
+
+        return toReturn;
+      });
+  }
+
+  /**
+   * Gets the player's previous score for a map.
+   *
+   * @param playerId the player's id to get the previous score for
+   * @param leaderboardId the leaderboard to get the previous score on
+   * @param timestamp the score's timestamp to get the previous score for
+   * @returns the score, or undefined if none
+   */
+  public static async getPreviousScore(
+    playerId: string,
+    leaderboardId: string,
+    timestamp: Date
+  ): Promise<ScoreSaberPreviousScore | undefined> {
+    const scores = await ScoreSaberScoreModel.find({ playerId: playerId, leaderboardId: leaderboardId }).sort({
+      timestamp: -1,
+    });
+    if (scores == null || scores.length == 0) {
+      return undefined;
+    }
+
+    const scoreIndex = scores.findIndex(score => score.timestamp.getTime() == timestamp.getTime());
+    const score = scores.find(score => score.timestamp.getTime() == timestamp.getTime());
+    if (scoreIndex == -1 || score == undefined) {
+      return undefined;
+    }
+    const previousScore = scores[scoreIndex + 1];
+    if (previousScore == undefined) {
+      return undefined;
+    }
+    return {
+      score: previousScore.score,
+      accuracy: previousScore.accuracy,
+      modifiers: previousScore.modifiers,
+      misses: previousScore.misses,
+      missedNotes: previousScore.missedNotes,
+      badCuts: previousScore.badCuts,
+      fullCombo: previousScore.fullCombo,
+      pp: previousScore.pp,
+      weight: previousScore.weight,
+      maxCombo: previousScore.maxCombo,
+      timestamp: previousScore.timestamp,
+      change: {
+        score: score.score - previousScore.score,
+        accuracy: score.accuracy - previousScore.accuracy,
+        misses: score.misses - previousScore.misses,
+        missedNotes: score.missedNotes - previousScore.missedNotes,
+        badCuts: score.badCuts - previousScore.badCuts,
+        pp: score.pp - previousScore.pp,
+        weight: score.weight && previousScore.weight && score.weight - previousScore.weight,
+        maxCombo: score.maxCombo - previousScore.maxCombo,
+      },
+    } as ScoreSaberPreviousScore;
+  }
+}

projects/backend/tsconfig.json

@@ -10,5 +10,7 @@
     "skipLibCheck": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
+    "jsx": "react",
+    "incremental": true
   }
 }

projects/common/package.json

@@ -19,6 +19,9 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "ky": "^1.7.2"
+    "@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 (in ms) 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/curve-point.ts

@@ -0,0 +1,14 @@
+export class CurvePoint {
+  constructor(
+    private acc: number,
+    private multiplier: number
+  ) {}
+
+  getAcc(): number {
+    return this.acc;
+  }
+
+  getMultiplier(): number {
+    return this.multiplier;
+  }
+}

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

@@ -1,4 +1,4 @@
-import { HttpCode } from "../common/http-codes";
+import { HttpCode } from "../http-codes";
 
 export class InternalServerError extends Error {
   constructor(

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

@@ -1,4 +1,4 @@
-import { HttpCode } from "../common/http-codes";
+import { HttpCode } from "../http-codes";
 
 export class NotFoundError extends Error {
   constructor(
@@ -7,4 +7,4 @@ export class NotFoundError extends Error {
   ) {
     super(message);
   }
-}
+}

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

@@ -1,4 +1,4 @@
-import { HttpCode } from "../common/http-codes";
+import { HttpCode } from "../http-codes";
 
 export class RateLimitError extends Error {
   constructor(
@@ -7,4 +7,4 @@ export class RateLimitError extends Error {
   ) {
     super(message);
   }
-}
+}

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/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/leaderboard/impl/scoresaber-leaderboard.ts

@@ -0,0 +1,56 @@
+import Leaderboard from "../leaderboard";
+import { type LeaderboardStatus } from "../leaderboard-status";
+import { getModelForClass, modelOptions, Prop, ReturnModelType, Severity } from "@typegoose/typegoose";
+import { Document } from "mongoose";
+
+@modelOptions({
+  options: { allowMixed: Severity.ALLOW },
+  schemaOptions: {
+    collection: "scoresaber-leaderboards",
+    toObject: {
+      virtuals: true,
+      transform: function (_, ret) {
+        ret.id = ret._id;
+        delete ret._id;
+        delete ret.__v;
+        return ret;
+      },
+    },
+  },
+})
+export default class ScoreSaberLeaderboardInternal extends Leaderboard {
+  /**
+   * The star count for the leaderboard.
+   */
+  @Prop({ required: true })
+  readonly stars!: number;
+
+  /**
+   * The total amount of plays.
+   */
+  @Prop({ required: true })
+  readonly plays!: number;
+
+  /**
+   * The amount of plays today.
+   */
+  @Prop({ required: true })
+  readonly dailyPlays!: number;
+
+  /**
+   * Whether this leaderboard is qualified to be ranked.
+   */
+  @Prop({ required: true })
+  readonly qualified!: boolean;
+
+  /**
+   * The status of the map.
+   */
+  @Prop({ required: true })
+  readonly status!: LeaderboardStatus;
+}
+
+export type ScoreSaberLeaderboard = InstanceType<typeof ScoreSaberLeaderboardInternal>;
+export type ScoreSaberLeaderboardDocument = ScoreSaberLeaderboard & Document;
+export const ScoreSaberLeaderboardModel: ReturnModelType<typeof ScoreSaberLeaderboardInternal> =
+  getModelForClass(ScoreSaberLeaderboardInternal);

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

@@ -0,0 +1,29 @@
+import { type MapDifficulty } from "../../score/map-difficulty";
+import { type MapCharacteristic } from "../../types/map-characteristic";
+import { Prop } from "@typegoose/typegoose";
+
+export default class LeaderboardDifficulty {
+  /**
+   * The id of the leaderboard.
+   */
+  @Prop({ required: true })
+  leaderboardId!: number;
+
+  /**
+   * The difficulty of the leaderboard.
+   */
+  @Prop({ required: true })
+  difficulty!: MapDifficulty;
+
+  /**
+   * The characteristic of the leaderboard.
+   */
+  @Prop({ required: true })
+  characteristic!: MapCharacteristic;
+
+  /**
+   * The raw difficulty of the leaderboard.
+   */
+  @Prop({ required: true })
+  difficultyRaw!: string;
+}

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

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

projects/common/src/model/leaderboard/leaderboard.ts

@@ -0,0 +1,99 @@
+import LeaderboardDifficulty from "./leaderboard-difficulty";
+import { Prop } from "@typegoose/typegoose";
+
+export default class Leaderboard {
+  /**
+   * The id of the leaderboard.
+   * @private
+   */
+  @Prop({ required: true })
+  private readonly _id?: number;
+
+  /**
+   * The hash of the song this leaderboard is for.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly songHash!: string;
+
+  /**
+   * The name of the song this leaderboard is for.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly songName!: string;
+
+  /**
+   * The sub name of the leaderboard.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly songSubName!: string;
+
+  /**
+   * The author of the song this leaderboard is for.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly songAuthorName!: string;
+
+  /**
+   * The author of the level this leaderboard is for.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly levelAuthorName!: string;
+
+  /**
+   * The difficulty of the leaderboard.
+   * @private
+   */
+  @Prop({ required: true, _id: false, type: () => LeaderboardDifficulty })
+  readonly difficulty!: LeaderboardDifficulty;
+
+  /**
+   * The difficulties of the leaderboard.
+   * @private
+   */
+  @Prop({ required: true, _id: false, type: () => [LeaderboardDifficulty] })
+  readonly difficulties!: LeaderboardDifficulty[];
+
+  /**
+   * The maximum score of the leaderboard.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly maxScore!: number;
+
+  /**
+   * Whether the leaderboard is ranked.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly ranked!: boolean;
+
+  /**
+   * The link to the song art.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly songArt!: string;
+
+  /**
+   * The date the leaderboard was created.
+   * @private
+   */
+  @Prop({ required: true })
+  readonly timestamp!: Date;
+
+  /**
+   * The date the leaderboard was last refreshed.
+   * @private
+   */
+  @Prop({ required: true })
+  lastRefreshed?: Date;
+
+  get id(): number {
+    return this._id ?? 0;
+  }
+}

projects/common/src/model/player.ts

@@ -1,7 +1,7 @@
 import { getModelForClass, modelOptions, prop, ReturnModelType, Severity } from "@typegoose/typegoose";
 import { Document } from "mongoose";
-import { PlayerHistory } from "@ssr/common/types/player/player-history";
-import { formatDateMinimal, getDaysAgoDate, getMidnightAlignedDate } from "@ssr/common/utils/time-utils";
+import { PlayerHistory } from "../player/player-history";
+import { formatDateMinimal, getDaysAgoDate, getMidnightAlignedDate } from "../utils/time-utils";
 
 /**
  * The model for a player.
@@ -14,12 +14,24 @@ export class Player {
   @prop()
   public _id!: string;
 
+  /**
+   * The player's name.
+   */
+  @prop()
+  public name?: string;
+
   /**
    * The player's statistic history.
    */
   @prop()
   private statisticHistory?: Record<string, PlayerHistory>;
 
+  /**
+   * Whether the player has their scores seeded.
+   */
+  @prop()
+  public seededScores?: boolean;
+
   /**
    * The date the player was last tracked.
    */
@@ -60,17 +72,15 @@ export class Player {
    * @param days the number of days to get the history for.
    */
   public getHistoryPreviousDays(days: number): Record<string, PlayerHistory> {
-    if (this.statisticHistory === undefined) {
-      this.statisticHistory = {};
-    }
+    const statisticHistory = this.getStatisticHistory();
     const history: Record<string, PlayerHistory> = {};
-    for (let i = 0; i < days; i++) {
+
+    for (let i = 0; i <= days; i++) {
       const date = formatDateMinimal(getMidnightAlignedDate(getDaysAgoDate(i)));
-      const playerHistory = this.getStatisticHistory()[date];
-      if (playerHistory === undefined || Object.keys(playerHistory).length === 0) {
-        continue;
+      const playerHistory = statisticHistory[date];
+      if (playerHistory !== undefined && Object.keys(playerHistory).length > 0) {
+        history[date] = playerHistory;
       }
-      history[date] = playerHistory;
     }
     return history;
   }
@@ -85,7 +95,7 @@ export class Player {
     if (this.statisticHistory === undefined) {
       this.statisticHistory = {};
     }
-    this.getStatisticHistory()[formatDateMinimal(getMidnightAlignedDate(date))] = history;
+    this.statisticHistory[formatDateMinimal(getMidnightAlignedDate(date))] = history;
   }
 
   /**
@@ -96,9 +106,9 @@ export class Player {
     if (this.statisticHistory === undefined) {
       this.statisticHistory = {};
     }
-    return Object.entries(this.getStatisticHistory())
-      .sort((a, b) => Date.parse(b[0]) - Date.parse(a[0]))
-      .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+    this.statisticHistory = Object.fromEntries(
+      Object.entries(this.statisticHistory).sort((a, b) => new Date(b[0]).getTime() - new Date(a[0]).getTime())
+    );
   }
 
   /**
@@ -111,8 +121,5 @@ export class Player {
   }
 }
 
-// This type defines a Mongoose document based on Player.
 export type PlayerDocument = Player & Document;
-
-// This type ensures that PlayerModel returns Mongoose documents (PlayerDocument) that have Mongoose methods (save, remove, etc.)
 export const PlayerModel: ReturnModelType<typeof Player> = getModelForClass(Player);

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

@@ -0,0 +1,101 @@
+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";
+import { PreviousScore } from "../previous-score";
+
+@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, index: true })
+  public 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;
+
+  /**
+   * The previous score, if any.
+   */
+  public previousScore?: ScoreSaberPreviousScore;
+}
+
+class ScoreSaberScorePublic extends ScoreSaberScoreInternal {
+  /**
+   * The player who set the score.
+   */
+  public playerInfo!: ScoreSaberLeaderboardPlayerInfoToken;
+}
+
+export type ScoreSaberPreviousScore = PreviousScore & {
+  /**
+   * The pp of the previous score.
+   */
+  pp: number;
+
+  /**
+   * The weight of the previous score.
+   */
+  weight: number;
+
+  /**
+   * The max combo of the previous score.
+   */
+  maxCombo: number;
+
+  /**
+   * The change between the previous score and the current score.
+   */
+  change?: ScoreSaberPreviousScore;
+};
+
+export type ScoreSaberScore = InstanceType<typeof ScoreSaberScorePublic>;
+export type ScoreSaberScoreDocument = ScoreSaberScore & Document;
+export const ScoreSaberScoreModel: ReturnModelType<typeof ScoreSaberScoreInternal> =
+  getModelForClass(ScoreSaberScoreInternal);

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

@@ -0,0 +1,43 @@
+import { Modifier } from "../../score/modifier";
+
+export type PreviousScore = {
+  /**
+   * The score of the previous score.
+   */
+  score: number;
+
+  /**
+   * The accuracy of the previous score.
+   */
+  accuracy: number;
+
+  /**
+   * The modifiers of the previous score.
+   */
+  modifiers?: Modifier[];
+
+  /**
+   * The misses of the previous score.
+   */
+  misses: number;
+
+  /**
+   * The missed notes of the previous score.
+   */
+  missedNotes: number;
+
+  /**
+   * The bad cuts of the previous score.
+   */
+  badCuts: number;
+
+  /**
+   * The full combo of the previous score.
+   */
+  fullCombo?: boolean;
+
+  /**
+   * When the previous score was set.
+   */
+  timestamp: Date;
+};

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()
+  public _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, index: true })
+  public readonly timestamp!: Date;
+}
+
+export type ScoreType = InstanceType<typeof Score>;

projects/common/src/pagination.ts

@@ -0,0 +1,103 @@
+import { Metadata } from "./types/metadata";
+import { NotFoundError } from "./error/not-found-error";
+
+type FetchItemsFunction<T> = (fetchItems: FetchItems) => Promise<T[]>;
+
+export class Pagination<T> {
+  private itemsPerPage: number = 0;
+  private totalItems: number = 0;
+  private items: T[] | null = null; // Optional array to hold set items
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Sets the total number of items.
+   * @param totalItems - Total number of items.
+   * @returns the pagination
+   */
+  setTotalItems(totalItems: number): Pagination<T> {
+    this.totalItems = totalItems;
+    return this;
+  }
+
+  /**
+   * Gets a page of items, using either static items or a dynamic fetchItems callback.
+   * @param page - The page number to retrieve.
+   * @param fetchItems - The async function to fetch items if setItems was not used.
+   * @returns A promise resolving to the page of items.
+   * @throws throws an error if the page number is invalid.
+   */
+  async getPage(page: number, fetchItems?: FetchItemsFunction<T>): Promise<Page<T>> {
+    const totalPages = Math.ceil(this.totalItems / this.itemsPerPage);
+
+    if (page < 1 || page > totalPages) {
+      throw new NotFoundError("Invalid page number");
+    }
+
+    // Calculate the range of items to fetch for the current page
+    const start = (page - 1) * this.itemsPerPage;
+    const end = start + this.itemsPerPage;
+
+    let pageItems: T[];
+
+    // Use set items if they are present, otherwise use fetchItems callback
+    if (this.items) {
+      pageItems = this.items.slice(start, end);
+    } else if (fetchItems) {
+      pageItems = await fetchItems(new FetchItems(start, end));
+    } else {
+      throw new Error("Items function is not set and no fetchItems callback provided");
+    }
+
+    return new Page<T>(pageItems, new Metadata(totalPages, this.totalItems, page, this.itemsPerPage));
+  }
+}
+
+class FetchItems {
+  readonly start: number;
+  readonly end: number;
+
+  constructor(start: number, end: number) {
+    this.start = start;
+    this.end = end;
+  }
+}
+
+export class Page<T> {
+  readonly items: T[];
+  readonly metadata: Metadata;
+
+  constructor(items: T[], metadata: Metadata) {
+    this.items = items;
+    this.metadata = metadata;
+  }
+
+  /**
+   * Converts the page to a JSON object.
+   */
+  toJSON() {
+    return {
+      items: this.items,
+      metadata: this.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 { StatisticRange } from "./player";
+
+export type PlayerStatValue = {
+  /**
+   * The type of the stat.
+   */
+  type: string;
+
+  /**
+   * The value of the stat.
+   */
+  value: (player: ScoreSaberPlayer, range: StatisticRange) => 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.ts

@@ -55,4 +55,7 @@ export default class Player {
   }
 }
 
-export type StatisticChange = PlayerHistory;
+export type StatisticRange = "daily" | "weekly" | "monthly";
+export type StatisticChange = {
+  [key in StatisticRange]: 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/response/top-scores-response.ts

@@ -0,0 +1,21 @@
+import { ScoreSaberLeaderboard } from "src/model/leaderboard/impl/scoresaber-leaderboard";
+import { ScoreSaberScore } from "../model/score/impl/scoresaber-score";
+import { PlayerScore } from "../score/player-score";
+import { Timeframe } from "../timeframe";
+
+export type TopScoresResponse = {
+  /**
+   * The top scores.
+   */
+  scores: PlayerScore<ScoreSaberScore, ScoreSaberLeaderboard>[];
+
+  /**
+   * The timeframe returned.
+   */
+  timeframe: Timeframe;
+
+  /**
+   * The amount of scores to fetch.
+   */
+  limit: number;
+};

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

@@ -2,17 +2,18 @@
  * The score modifiers.
  */
 export enum Modifier {
-  DA = "Disappearing Arrows",
+  NF = "No Fail",
+  PM = "Pro Mode",
   FS = "Faster Song",
   SF = "Super Fast Song",
   SS = "Slower Song",
   GN = "Ghost Notes",
-  NA = "No Arrows",
-  NO = "No Obstacles",
+  DA = "Disappearing Arrows",
   SA = "Strict Angles",
   SC = "Small Notes",
-  PM = "Pro Mode",
-  CS = "Fail on Saber Clash",
   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

@@ -1,5 +1,5 @@
 import Service from "../service";
-import { BeatSaverMapToken } from "../../types/token/beatsaver/beat-saver-map-token";
+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`;
@@ -13,7 +13,6 @@ class BeatSaverService extends Service {
    * Gets the map that match the query.
    *
    * @param query the query to search for
-   * @param useProxy whether to use the proxy or not
    * @returns the map that match the query, or undefined if no map were found
    */
   async lookupMap(query: string): Promise<BeatSaverMapToken | undefined> {

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

@@ -2,10 +2,13 @@ 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 "../../types/score/score-sort";
+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 "../../curve-point";
+import { SSRCache } from "../../cache";
 
 const API_BASE = "https://scoresaber.com/api";
 
@@ -24,7 +27,53 @@ const LOOKUP_PLAYER_SCORES_ENDPOINT = `${API_BASE}/player/:id/scores?limit=:limi
 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, // 1 minute
+});
+
 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");
   }
@@ -35,7 +84,7 @@ class ScoreSaberService extends Service {
    * @param query the query to search for
    * @returns the players that match the query, or undefined if no players were found
    */
-  async searchPlayers(query: string): Promise<ScoreSaberPlayerSearchToken | undefined> {
+  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));
@@ -54,9 +103,13 @@ class ScoreSaberService extends Service {
    * 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
    */
-  async lookupPlayer(playerId: string): Promise<ScoreSaberPlayerToken | 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));
@@ -64,6 +117,9 @@ class ScoreSaberService extends Service {
       return undefined;
     }
     this.log(`Found player "${playerId}" in ${(performance.now() - before).toFixed(0)}ms`);
+    if (cache) {
+      playerCache.set(playerId, token);
+    }
     return token;
   }
 
@@ -73,7 +129,7 @@ class ScoreSaberService extends Service {
    * @param page the page to get players for
    * @returns the players on the page, or undefined
    */
-  async lookupPlayers(page: number): Promise<ScoreSaberPlayersPageToken | 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>(
@@ -93,7 +149,7 @@ class ScoreSaberService extends Service {
    * @param country the country to get players for
    * @returns the players on the page, or undefined
    */
-  async lookupPlayersByCountry(page: number, country: string): Promise<ScoreSaberPlayersPageToken | 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>(
@@ -111,18 +167,21 @@ class ScoreSaberService extends Service {
    *
    * @param playerId the ID of the player to look up
    * @param sort the sort to use
+   * @param limit the amount of sores to fetch
    * @param page the page to get scores for
-   * @param search
+   * @param search the query to search for
    * @returns the scores of the player, or undefined
    */
-  async lookupPlayerScores({
+  public async lookupPlayerScores({
     playerId,
     sort,
+    limit = 8,
     page,
     search,
   }: {
     playerId: string;
     sort: ScoreSort;
+    limit?: number;
     page: number;
     search?: string;
     useProxy?: boolean;
@@ -133,7 +192,7 @@ class ScoreSaberService extends Service {
     );
     const response = await this.fetch<ScoreSaberPlayerScoresPageToken>(
       LOOKUP_PLAYER_SCORES_ENDPOINT.replace(":id", playerId)
-        .replace(":limit", 8 + "")
+        .replace(":limit", limit + "")
         .replace(":sort", sort)
         .replace(":page", page + "") + (search ? `&search=${search}` : "")
     );
@@ -151,7 +210,7 @@ class ScoreSaberService extends Service {
    *
    * @param leaderboardId the ID of the leaderboard to look up
    */
-  async lookupLeaderboard(leaderboardId: string): Promise<ScoreSaberLeaderboardToken | undefined> {
+  public async lookupLeaderboard(leaderboardId: string): Promise<ScoreSaberLeaderboardToken | undefined> {
     const before = performance.now();
     this.log(`Looking up leaderboard "${leaderboardId}"...`);
     const response = await this.fetch<ScoreSaberLeaderboardToken>(
@@ -171,7 +230,7 @@ class ScoreSaberService extends Service {
    * @param page the page to get scores for
    * @returns the scores of the leaderboard, or undefined
    */
-  async lookupLeaderboardScores(
+  public async lookupLeaderboardScores(
     leaderboardId: string,
     page: number
   ): Promise<ScoreSaberLeaderboardScoresPageToken | undefined> {
@@ -188,6 +247,53 @@ class ScoreSaberService extends Service {
     );
     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,4 +1,5 @@
 import ky from "ky";
+import { isServer } from "../utils/utils";
 
 export default class Service {
   /**
@@ -38,9 +39,12 @@ export default class Service {
    */
   public async fetch<T>(url: string): Promise<T | undefined> {
     try {
-      return await ky.get<T>(this.buildRequestUrl(true, url)).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/timeframe.ts

@@ -0,0 +1 @@
+export type Timeframe = "daily" | "weekly" | "monthly";

projects/common/src/token-creators.ts

@@ -0,0 +1,331 @@
+import ScoreSaberLeaderboard from "./model/leaderboard/impl/scoresaber-leaderboard";
+import ScoreSaberLeaderboardToken from "./types/token/scoresaber/score-saber-leaderboard-token";
+import LeaderboardDifficulty from "./model/leaderboard/leaderboard-difficulty";
+import { getDifficultyFromScoreSaberDifficulty } from "./utils/scoresaber-utils";
+import { MapCharacteristic } from "./types/map-characteristic";
+import { LeaderboardStatus } from "./model/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: leaderboard.maxScore ? (token.baseScore / leaderboard.maxScore) * 100 : Infinity,
+    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,26 @@
+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;
+
+  /**
+   * The amount of cached ScoreSaber leaderboards.
+   */
+  cachedScoreSaberLeaderboards: 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/player/impl/scoresaber-player.ts

@@ -1,264 +0,0 @@
-import Player, { StatisticChange } from "../player";
-import ky from "ky";
-import { PlayerHistory } from "../player-history";
-import ScoreSaberPlayerToken from "../../token/scoresaber/score-saber-player-token";
-import { formatDateMinimal, getDaysAgoDate, getMidnightAlignedDate } from "../../../utils/time-utils";
-
-/**
- * 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: ScoreSaberRole | 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;
-
-  /**
-   * 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;
-}
-
-/**
- * Gets the ScoreSaber Player from an {@link ScoreSaberPlayerToken}.
- *
- * @param token the player token
- * @param apiUrl the api url for SSR
- * @param playerIdCookie the player id cookie (doesn't need to be set)
- */
-export async function getScoreSaberPlayerFromToken(
-  token: ScoreSaberPlayerToken,
-  apiUrl: string,
-  playerIdCookie?: string
-): Promise<ScoreSaberPlayer> {
-  const bio: ScoreSaberBio = {
-    lines: token.bio?.split("\n") || [],
-    linesStripped: token.bio?.replace(/<[^>]+>/g, "")?.split("\n") || [],
-  };
-  const role = token.role == null ? undefined : (token.role as ScoreSaberRole);
-  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 };
-      }>(
-        `${apiUrl}/player/history/${token.id}${playerIdCookie && playerIdCookie == token.id ? "?createIfMissing=true" : ""}`
-      )
-      .json();
-    if (history === undefined || Object.entries(history).length === 0) {
-      console.log("Player has no history, using fallback");
-      throw new Error();
-    }
-    if (history) {
-      // Use the latest data for today
-      history[todayDate] = {
-        rank: token.rank,
-        countryRank: token.countryRank,
-        pp: token.pp,
-        accuracy: {
-          averageRankedAccuracy: token.scoreStats.averageRankedAccuracy,
-        },
-      };
-
-      isBeingTracked = true;
-    }
-    statisticHistory = history;
-  } catch (error) {
-    // Fallback to ScoreSaber History if the player has no history
-    const playerRankHistory = token.histories.split(",").map(value => {
-      return parseInt(value);
-    });
-    playerRankHistory.push(token.rank);
-
-    let daysAgo = 0; // Start from current day
-    for (let i = playerRankHistory.length - 1; i >= 0; i--) {
-      const rank = playerRankHistory[i];
-      const date = getMidnightAlignedDate(getDaysAgoDate(daysAgo));
-      daysAgo += 1; // Increment daysAgo for each earlier rank
-
-      statisticHistory[formatDateMinimal(date)] = {
-        rank: rank,
-      };
-    }
-  }
-  // 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 }), {});
-
-  const yesterdayDate = formatDateMinimal(getMidnightAlignedDate(getDaysAgoDate(1)));
-  const todayStats = statisticHistory[todayDate];
-  const yesterdayStats = statisticHistory[yesterdayDate];
-  const hasChange = !!(todayStats && yesterdayStats);
-
-  /**
-   * Gets the change in the given stat
-   *
-   * @param statType the stat to check
-   * @return the change
-   */
-  const getChange = (statType: "rank" | "countryRank" | "pp"): number => {
-    if (!hasChange) {
-      return 0;
-    }
-    const statToday = todayStats[`${statType}`];
-    const statYesterday = yesterdayStats[`${statType}`];
-    return !!(statToday && statYesterday) ? statToday - statYesterday : 0;
-  };
-
-  // Calculate the changes
-  const rankChange = getChange("rank");
-  const countryRankChange = getChange("countryRank");
-  const ppChange = getChange("pp");
-
-  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: {
-      rank: rankChange * -1, // Reverse the rank change
-      countryRank: countryRankChange * -1, // Reverse the country rank change
-      pp: ppChange,
-    },
-    role: role,
-    badges: badges,
-    statisticHistory: statisticHistory,
-    statistics: token.scoreStats,
-    permissions: token.permissions,
-    banned: token.banned,
-    inactive: token.inactive,
-    isBeingTracked: isBeingTracked,
-  };
-}
-
-/**
- * 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[];
-};
-
-/**
- * The ScoreSaber account roles.
- */
-export type ScoreSaberRole = "Admin";
-
-/**
- * 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;
-};

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

@@ -1,26 +0,0 @@
-export interface PlayerHistory {
-  /**
-   * The player's rank.
-   */
-  rank?: number;
-
-  /**
-   * The player's country rank.
-   */
-  countryRank?: number;
-
-  /**
-   * The pp of the player.
-   */
-  pp?: number;
-
-  /**
-   * The player's accuracy.
-   */
-  accuracy?: {
-    /**
-     * The player's average ranked accuracy.
-     */
-    averageRankedAccuracy?: number;
-  };
-}

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

@@ -1,47 +0,0 @@
-import Score from "../score";
-import { Modifier } from "../modifier";
-import ScoreSaberScoreToken from "../../token/scoresaber/score-saber-score-token";
-
-export default class ScoreSaberScore extends Score {
-  constructor(
-    score: number,
-    weight: number | undefined,
-    rank: number,
-    worth: number,
-    modifiers: Modifier[],
-    misses: number,
-    badCuts: number,
-    fullCombo: boolean,
-    timestamp: Date
-  ) {
-    super(score, weight, rank, worth, modifiers, misses, badCuts, fullCombo, timestamp);
-  }
-
-  /**
-   * Gets a {@link ScoreSaberScore} from a {@link ScoreSaberScoreToken}.
-   *
-   * @param token the token to convert
-   */
-  public static fromToken(token: ScoreSaberScoreToken): ScoreSaberScore {
-    const modifiers: Modifier[] = 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 new ScoreSaberScore(
-      token.baseScore,
-      token.weight,
-      token.rank,
-      token.pp,
-      modifiers,
-      token.missedNotes,
-      token.badCuts,
-      token.fullCombo,
-      new Date(token.timeSet)
-    );
-  }
-}

projects/common/src/types/score/score.ts

@@ -1,116 +0,0 @@
-import { Modifier } from "./modifier";
-
-export default class Score {
-  /**
-   * The base score for the score.
-   * @private
-   */
-  private readonly _score: number;
-
-  /**
-   * The weight of the score, or undefined if not ranked.s
-   * @private
-   */
-  private readonly _weight: number | undefined;
-
-  /**
-   * The rank for the score.
-   * @private
-   */
-  private readonly _rank: number;
-
-  /**
-   * The worth of the score (this could be pp, ap, cr, etc.),
-   * or undefined if not ranked.
-   * @private
-   */
-  private readonly _worth: number;
-
-  /**
-   * The modifiers used on the score.
-   * @private
-   */
-  private readonly _modifiers: Modifier[];
-
-  /**
-   * The amount missed notes.
-   * @private
-   */
-  private readonly _misses: number;
-
-  /**
-   * The amount of bad cuts.
-   * @private
-   */
-  private readonly _badCuts: number;
-
-  /**
-   * Whether every note was hit.
-   * @private
-   */
-  private readonly _fullCombo: boolean;
-
-  /**
-   * The time the score was set.
-   * @private
-   */
-  private readonly _timestamp: Date;
-
-  constructor(
-    score: number,
-    weight: number | undefined,
-    rank: number,
-    worth: number,
-    modifiers: Modifier[],
-    misses: number,
-    badCuts: number,
-    fullCombo: boolean,
-    timestamp: Date
-  ) {
-    this._score = score;
-    this._weight = weight;
-    this._rank = rank;
-    this._worth = worth;
-    this._modifiers = modifiers;
-    this._misses = misses;
-    this._badCuts = badCuts;
-    this._fullCombo = fullCombo;
-    this._timestamp = timestamp;
-  }
-
-  get score(): number {
-    return this._score;
-  }
-
-  get weight(): number | undefined {
-    return this._weight;
-  }
-
-  get rank(): number {
-    return this._rank;
-  }
-
-  get worth(): number {
-    return this._worth;
-  }
-
-  get modifiers(): Modifier[] {
-    return this._modifiers;
-  }
-
-  get misses(): number {
-    return this._misses;
-  }
-
-  get badCuts(): number {
-    return this._badCuts;
-  }
-
-  get fullCombo(): boolean {
-    return this._fullCombo;
-  }
-
-  get timestamp(): Date {
-    return this._timestamp;
-  }
-}

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;
+};

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

@@ -0,0 +1,16 @@
+import { BeatLeaderSongToken } from "./score/song";
+import { BeatLeaderDifficultyToken } from "./difficulty";
+
+export type BeatLeaderLeaderboardToken = {
+  id: string;
+  song: BeatLeaderSongToken;
+  difficulty: BeatLeaderDifficultyToken;
+  scores: null; // ??
+  changes: null; // ??
+  qualification: null; // ??
+  reweight: null; // ??
+  leaderboardGroup: null; // ??
+  plays: number;
+  clan: null; // ??
+  clanRankingContested: boolean;
+};

projects/common/src/types/token/beatleader/modifier/modifier-rating.ts

@@ -0,0 +1,18 @@
+export type BeatLeaderModifierRatingToken = {
+  id: number;
+  fsPredictedAcc: number;
+  fsPassRating: number;
+  fsAccRating: number;
+  fsTechRating: number;
+  fsStars: number;
+  ssPredictedAcc: number;
+  ssPassRating: number;
+  ssAccRating: number;
+  ssTechRating: number;
+  ssStars: number;
+  sfPredictedAcc: number;
+  sfPassRating: number;
+  sfAccRating: number;
+  sfTechRating: number;
+  sfStars: number;
+};

projects/common/src/types/token/beatleader/modifier/modifiers.ts

@@ -0,0 +1,16 @@
+export type BeatLeaderModifierToken = {
+  modifierId: number;
+  da: number;
+  fs: number;
+  sf: number;
+  ss: number;
+  gn: number;
+  na: number;
+  nb: number;
+  nf: number;
+  no: number;
+  pm: number;
+  sc: number;
+  sa: number;
+  op: number;
+};

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

@@ -0,0 +1,10 @@
+export type BeatLeaderPlayerToken = {
+  id: string;
+  country: string;
+  avatar: string;
+  pp: number;
+  rank: number;
+  countryRank: number;
+  name: string;
+  // todo: finish this
+};

projects/common/src/types/token/beatleader/score-stats/accuracy-tracker.ts

@@ -0,0 +1,66 @@
+export type ScoreStatsAccuracyTrackerToken = {
+  /**
+   * The accuracy of the right hand.
+   */
+  accRight: number;
+
+  /**
+   * The accuracy of the left hand.
+   */
+  accLeft: number;
+
+  /**
+   * The left hand pre-swing.
+   */
+  leftPreswing: number;
+
+  /**
+   * The right hand pre-swing.
+   */
+  rightPreswing: number;
+
+  /**
+   * The average pre-swing.
+   */
+  averagePreswing: number;
+
+  /**
+   * The left hand post-swing.
+   */
+  leftPostswing: number;
+
+  /**
+   * The right hand post-swing.
+   */
+  rightPostswing: number;
+
+  /**
+   * The left hand time dependence.
+   */
+  leftTimeDependence: number;
+
+  /**
+   * The right hand time dependence.
+   */
+  rightTimeDependence: number;
+
+  /**
+   * The left hand average cut.
+   */
+  leftAverageCut: number[];
+
+  /**
+   * The right hand average cut.
+   */
+  rightAverageCut: number[];
+
+  /**
+   * The grid accuracy.
+   */
+  gridAcc: number[];
+
+  /**
+   * The full combo accuracy.
+   */
+  fcAcc: number;
+};

projects/common/src/types/token/beatleader/score-stats/head-position.ts

@@ -0,0 +1,16 @@
+export type ScoreStatsHeadPositionToken = {
+  /**
+   * The X position of the head
+   */
+  x: number;
+
+  /**
+   * The Y position of the head
+   */
+  y: number;
+
+  /**
+   * The Z position of the head
+   */
+  z: number;
+};

projects/common/src/types/token/beatleader/score-stats/hit-tracker.ts

@@ -0,0 +1,51 @@
+export type ScoreStatsHitTrackerToken = {
+  /**
+   * The maximum combo achieved.
+   */
+  maxCombo: number;
+
+  /**
+   * The highest amount of 115 notes hit in a row.
+   */
+  maxStreak: number;
+
+  /**
+   * The left hand timing.
+   */
+  leftTiming: number;
+
+  /**
+   * The right hand timing.
+   */
+  rightTiming: number;
+
+  /**
+   * The left hand misses.
+   */
+  leftMiss: number;
+
+  /**
+   * The right hand misses.
+   */
+  rightMiss: number;
+
+  /**
+   * The left hand bad cuts.
+   */
+  leftBadCuts: number;
+
+  /**
+   * The right hand bad cuts.
+   */
+  rightBadCuts: number;
+
+  /**
+   * The left hand bombs.
+   */
+  leftBombs: number;
+
+  /**
+   * The right hand bombs.
+   */
+  rightBombs: number;
+};

projects/common/src/types/token/beatleader/score-stats/score-graph-tracker.ts

@@ -0,0 +1,6 @@
+export type ScoreStatsGraphTrackerToken = {
+  /**
+   * The accuracy graph data.
+   */
+  graph: number[];
+};

projects/common/src/types/token/beatleader/score-stats/score-stats.ts

@@ -0,0 +1,26 @@
+import { ScoreStatsHitTrackerToken } from "./hit-tracker";
+import { ScoreStatsAccuracyTrackerToken } from "./accuracy-tracker";
+import { ScoreStatsWinTrackerToken } from "./win-tracker";
+import { ScoreStatsGraphTrackerToken } from "./score-graph-tracker";
+
+export type ScoreStatsToken = {
+  /**
+   * The hit tracker stats.
+   */
+  hitTracker: ScoreStatsHitTrackerToken;
+
+  /**
+   * The accuracy tracker stats.
+   */
+  accuracyTracker: ScoreStatsAccuracyTrackerToken;
+
+  /**
+   * The win tracker stats.
+   */
+  winTracker: ScoreStatsWinTrackerToken;
+
+  /**
+   * The score graph tracker stats.
+   */
+  scoreGraphTracker: ScoreStatsGraphTrackerToken;
+};

projects/common/src/types/token/beatleader/score-stats/win-tracker.ts

@@ -0,0 +1,48 @@
+import { ScoreStatsHeadPositionToken } from "./head-position";
+
+export type ScoreStatsWinTrackerToken = {
+  /**
+   * Whether the score was won. (not failed)
+   */
+  won: boolean;
+
+  /**
+   * The time the score ended.
+   */
+  endTime: number;
+
+  /**
+   * The total amount of pauses.
+   */
+  nbOfPause: number;
+
+  /**
+   * The total amount of pause time.
+   */
+  totalPauseDuration: number;
+
+  /**
+   * The jump distance the score was played on.
+   */
+  jumpDistance: number;
+
+  /**
+   * The average height of the player.
+   */
+  averageHeight: number;
+
+  /**
+   * The average head position of the player.
+   */
+  averageHeadPosition: ScoreStatsHeadPositionToken;
+
+  /**
+   * The total score.
+   */
+  totalScore: number;
+
+  /**
+   * The maximum score for this song.
+   */
+  maxScore: number;
+};