feat: add URLCrypto service for encoding and decoding URLs in base64url format

Author: AlexTraveylan

lib/url-transformer.service.ts

@@ -0,0 +1,54 @@
+import { createHash } from "crypto"
+
+export class URLCrypto {
+  private static readonly SEPARATOR = "-"
+
+  static toBase64Url(url: string): string {
+    try {
+      new URL(url)
+    } catch (error) {
+      throw new Error(`URL invalide: ${url}`)
+    }
+
+    const hash = createHash("sha256").update(url).digest("base64url").slice(0, 8)
+    const encoded = Buffer.from(url).toString("base64url")
+
+    return `${encoded}${this.SEPARATOR}${hash}`
+  }
+
+  static fromBase64Url(encoded: string): string {
+    try {
+      const [urlPart, hashPart] = encoded.split(this.SEPARATOR)
+      if (!urlPart || !hashPart) {
+        throw new Error("Format invalide")
+      }
+
+      const decodedUrl = Buffer.from(urlPart, "base64url").toString()
+
+      const expectedHash = createHash("sha256")
+        .update(decodedUrl)
+        .digest("base64url")
+        .slice(0, 8)
+
+      if (hashPart !== expectedHash) {
+        throw new Error("Hash de vérification invalide")
+      }
+
+      new URL(decodedUrl)
+
+      return decodedUrl
+    } catch (error) {
+      console.error(error)
+      throw new Error(`Décodage impossible`)
+    }
+  }
+
+  static isValid(encoded: string): boolean {
+    try {
+      this.fromBase64Url(encoded)
+      return true
+    } catch {
+      return false
+    }
+  }
+}

lib/url-transformer.test.ts

@@ -0,0 +1,113 @@
+import { URLCrypto } from "./url-transformer.service"
+
+describe("URLCrypto", () => {
+  // Tests d'encodage
+  describe("toBase64Url", () => {
+    test("devrait encoder une URL valide", () => {
+      const url = "https://www.alextraveylan.fr/fr"
+      const encoded = URLCrypto.toBase64Url(url)
+
+      expect(encoded).toBeDefined()
+      expect(encoded).toContain("-")
+      expect(encoded.split("-")).toHaveLength(2)
+    })
+
+    test("devrait rejeter une URL invalide", () => {
+      const invalidUrl = "not-a-url"
+
+      expect(() => {
+        URLCrypto.toBase64Url(invalidUrl)
+      }).toThrow("URL invalide")
+    })
+
+    test("devrait gérer les URLs avec des caractères spéciaux", () => {
+      const urlWithSpecialChars = "https://example.com/path?param=value&special=@#$"
+      const encoded = URLCrypto.toBase64Url(urlWithSpecialChars)
+
+      expect(encoded).toBeDefined()
+      expect(URLCrypto.fromBase64Url(encoded)).toBe(urlWithSpecialChars)
+    })
+  })
+
+  // Tests de décodage
+  describe("fromBase64Url", () => {
+    test("devrait décoder une string encodée valide", () => {
+      const originalUrl = "https://www.alextraveylan.fr/fr"
+      const encoded = URLCrypto.toBase64Url(originalUrl)
+      const decoded = URLCrypto.fromBase64Url(encoded)
+
+      expect(decoded).toBe(originalUrl)
+    })
+
+    test("devrait rejeter une string encodée invalide", () => {
+      const invalidEncoded = "invalid-encoded-string"
+
+      expect(() => {
+        URLCrypto.fromBase64Url(invalidEncoded)
+      }).toThrow("Décodage impossible")
+    })
+
+    test("devrait rejeter une string avec un hash incorrect", () => {
+      const encoded = URLCrypto.toBase64Url("https://www.alextraveylan.fr/fr")
+      const corruptedEncoded = encoded.slice(0, -1) + "X"
+
+      expect(() => {
+        URLCrypto.fromBase64Url(corruptedEncoded)
+      }).toThrow("Décodage impossible")
+    })
+  })
+
+  // Tests de validation
+  describe("isValid", () => {
+    test("devrait retourner true pour une string encodée valide", () => {
+      const url = "https://www.alextraveylan.fr/fr"
+      const encoded = URLCrypto.toBase64Url(url)
+
+      expect(URLCrypto.isValid(encoded)).toBe(true)
+    })
+
+    test("devrait retourner false pour une string encodée invalide", () => {
+      expect(URLCrypto.isValid("invalid-string")).toBe(false)
+    })
+  })
+
+  // Tests de cas limites
+  describe("edge cases", () => {
+    test("devrait gérer les URLs très longues", () => {
+      const longUrl = "https://example.com/" + "a".repeat(1000)
+      const encoded = URLCrypto.toBase64Url(longUrl)
+      const decoded = URLCrypto.fromBase64Url(encoded)
+
+      expect(decoded).toBe(longUrl)
+    })
+
+    test("devrait gérer les URLs avec des fragments", () => {
+      const urlWithFragment = "https://example.com/page#section"
+      const encoded = URLCrypto.toBase64Url(urlWithFragment)
+      const decoded = URLCrypto.fromBase64Url(encoded)
+
+      expect(decoded).toBe(urlWithFragment)
+    })
+
+    test("devrait gérer les URLs avec des query params complexes", () => {
+      const urlWithParams = "https://example.com/search?q=test&filter[]=1&filter[]=2"
+      const encoded = URLCrypto.toBase64Url(urlWithParams)
+      const decoded = URLCrypto.fromBase64Url(encoded)
+
+      expect(decoded).toBe(urlWithParams)
+    })
+  })
+
+  // Test de round-trip
+  describe("round-trip", () => {
+    test("devrait préserver l'URL après encodage/décodage multiple", () => {
+      const originalUrl = "https://www.alextraveylan.fr/fr"
+      const encoded1 = URLCrypto.toBase64Url(originalUrl)
+      const decoded1 = URLCrypto.fromBase64Url(encoded1)
+      const encoded2 = URLCrypto.toBase64Url(decoded1)
+      const decoded2 = URLCrypto.fromBase64Url(encoded2)
+
+      expect(decoded2).toBe(originalUrl)
+    })
+  })
+})