refactor(frontend): delete utility libraries and validation #69

-205

frontend/src/lib/utils/array.ts

··· 1 1 - import type { Option } from "./option.ts"; 2 2 - 3 3 - export function first<T>(arr: readonly T[]): Option<T> { 4 4 - return arr[0] ?? null; 5 5 - } 6 6 - 7 7 - export function last<T>(arr: readonly T[]): Option<T> { 8 8 - return arr[arr.length - 1] ?? null; 9 9 - } 10 10 - 11 11 - export function at<T>(arr: readonly T[], index: number): Option<T> { 12 12 - if (index < 0) index = arr.length + index; 13 13 - return arr[index] ?? null; 14 14 - } 15 15 - 16 16 - export function find<T>( 17 17 - arr: readonly T[], 18 18 - predicate: (t: T) => boolean, 19 19 - ): Option<T> { 20 20 - return arr.find(predicate) ?? null; 21 21 - } 22 22 - 23 23 - export function findMap<T, U>( 24 24 - arr: readonly T[], 25 25 - fn: (t: T) => Option<U>, 26 26 - ): Option<U> { 27 27 - for (const item of arr) { 28 28 - const result = fn(item); 29 29 - if (result != null) return result; 30 30 - } 31 31 - return null; 32 32 - } 33 33 - 34 34 - export function findIndex<T>( 35 35 - arr: readonly T[], 36 36 - predicate: (t: T) => boolean, 37 37 - ): Option<number> { 38 38 - const index = arr.findIndex(predicate); 39 39 - return index >= 0 ? index : null; 40 40 - } 41 41 - 42 42 - export function partition<T>( 43 43 - arr: readonly T[], 44 44 - predicate: (t: T) => boolean, 45 45 - ): [T[], T[]] { 46 46 - const pass: T[] = []; 47 47 - const fail: T[] = []; 48 48 - for (const item of arr) { 49 49 - if (predicate(item)) { 50 50 - pass.push(item); 51 51 - } else { 52 52 - fail.push(item); 53 53 - } 54 54 - } 55 55 - return [pass, fail]; 56 56 - } 57 57 - 58 58 - export function groupBy<T, K extends string | number>( 59 59 - arr: readonly T[], 60 60 - keyFn: (t: T) => K, 61 61 - ): Record<K, T[]> { 62 62 - const result = {} as Record<K, T[]>; 63 63 - for (const item of arr) { 64 64 - const key = keyFn(item); 65 65 - if (!result[key]) { 66 66 - result[key] = []; 67 67 - } 68 68 - result[key].push(item); 69 69 - } 70 70 - return result; 71 71 - } 72 72 - 73 73 - export function unique<T>(arr: readonly T[]): T[] { 74 74 - return [...new Set(arr)]; 75 75 - } 76 76 - 77 77 - export function uniqueBy<T, K>(arr: readonly T[], keyFn: (t: T) => K): T[] { 78 78 - const seen = new Set<K>(); 79 79 - const result: T[] = []; 80 80 - for (const item of arr) { 81 81 - const key = keyFn(item); 82 82 - if (!seen.has(key)) { 83 83 - seen.add(key); 84 84 - result.push(item); 85 85 - } 86 86 - } 87 87 - return result; 88 88 - } 89 89 - 90 90 - export function sortBy<T>( 91 91 - arr: readonly T[], 92 92 - keyFn: (t: T) => number | string, 93 93 - ): T[] { 94 94 - return [...arr].sort((a, b) => { 95 95 - const ka = keyFn(a); 96 96 - const kb = keyFn(b); 97 97 - if (ka < kb) return -1; 98 98 - if (ka > kb) return 1; 99 99 - return 0; 100 100 - }); 101 101 - } 102 102 - 103 103 - export function sortByDesc<T>( 104 104 - arr: readonly T[], 105 105 - keyFn: (t: T) => number | string, 106 106 - ): T[] { 107 107 - return [...arr].sort((a, b) => { 108 108 - const ka = keyFn(a); 109 109 - const kb = keyFn(b); 110 110 - if (ka > kb) return -1; 111 111 - if (ka < kb) return 1; 112 112 - return 0; 113 113 - }); 114 114 - } 115 115 - 116 116 - export function chunk<T>(arr: readonly T[], size: number): T[][] { 117 117 - const result: T[][] = []; 118 118 - for (let i = 0; i < arr.length; i += size) { 119 119 - result.push(arr.slice(i, i + size)); 120 120 - } 121 121 - return result; 122 122 - } 123 123 - 124 124 - export function zip<T, U>(a: readonly T[], b: readonly U[]): [T, U][] { 125 125 - const length = Math.min(a.length, b.length); 126 126 - const result: [T, U][] = []; 127 127 - for (let i = 0; i < length; i++) { 128 128 - result.push([a[i], b[i]]); 129 129 - } 130 130 - return result; 131 131 - } 132 132 - 133 133 - export function zipWith<T, U, R>( 134 134 - a: readonly T[], 135 135 - b: readonly U[], 136 136 - fn: (t: T, u: U) => R, 137 137 - ): R[] { 138 138 - const length = Math.min(a.length, b.length); 139 139 - const result: R[] = []; 140 140 - for (let i = 0; i < length; i++) { 141 141 - result.push(fn(a[i], b[i])); 142 142 - } 143 143 - return result; 144 144 - } 145 145 - 146 146 - export function intersperse<T>(arr: readonly T[], separator: T): T[] { 147 147 - if (arr.length <= 1) return [...arr]; 148 148 - const result: T[] = [arr[0]]; 149 149 - for (let i = 1; i < arr.length; i++) { 150 150 - result.push(separator, arr[i]); 151 151 - } 152 152 - return result; 153 153 - } 154 154 - 155 155 - export function range(start: number, end: number): number[] { 156 156 - const result: number[] = []; 157 157 - for (let i = start; i < end; i++) { 158 158 - result.push(i); 159 159 - } 160 160 - return result; 161 161 - } 162 162 - 163 163 - export function isEmpty<T>(arr: readonly T[]): boolean { 164 164 - return arr.length === 0; 165 165 - } 166 166 - 167 167 - export function isNonEmpty<T>(arr: readonly T[]): arr is [T, ...T[]] { 168 168 - return arr.length > 0; 169 169 - } 170 170 - 171 171 - export function sum(arr: readonly number[]): number { 172 172 - return arr.reduce((acc, n) => acc + n, 0); 173 173 - } 174 174 - 175 175 - export function sumBy<T>(arr: readonly T[], fn: (t: T) => number): number { 176 176 - return arr.reduce((acc, t) => acc + fn(t), 0); 177 177 - } 178 178 - 179 179 - export function maxBy<T>(arr: readonly T[], fn: (t: T) => number): Option<T> { 180 180 - if (arr.length === 0) return null; 181 181 - let max = arr[0]; 182 182 - let maxValue = fn(max); 183 183 - for (let i = 1; i < arr.length; i++) { 184 184 - const value = fn(arr[i]); 185 185 - if (value > maxValue) { 186 186 - max = arr[i]; 187 187 - maxValue = value; 188 188 - } 189 189 - } 190 190 - return max; 191 191 - } 192 192 - 193 193 - export function minBy<T>(arr: readonly T[], fn: (t: T) => number): Option<T> { 194 194 - if (arr.length === 0) return null; 195 195 - let min = arr[0]; 196 196 - let minValue = fn(min); 197 197 - for (let i = 1; i < arr.length; i++) { 198 198 - const value = fn(arr[i]); 199 199 - if (value < minValue) { 200 200 - min = arr[i]; 201 201 - minValue = value; 202 202 - } 203 203 - } 204 204 - return min; 205 205 - }

-245

frontend/src/lib/utils/async.ts

··· 1 1 - import { err, type Result } from "../types/result.ts"; 2 2 - 3 3 - export function debounce<T extends (...args: Parameters<T>) => void>( 4 4 - fn: T, 5 5 - ms: number, 6 6 - ): T & { cancel: () => void } { 7 7 - let timeoutId: ReturnType<typeof setTimeout> | null = null; 8 8 - 9 9 - const debounced = ((...args: Parameters<T>) => { 10 10 - if (timeoutId) clearTimeout(timeoutId); 11 11 - timeoutId = setTimeout(() => { 12 12 - fn(...args); 13 13 - timeoutId = null; 14 14 - }, ms); 15 15 - }) as T & { cancel: () => void }; 16 16 - 17 17 - debounced.cancel = () => { 18 18 - if (timeoutId) { 19 19 - clearTimeout(timeoutId); 20 20 - timeoutId = null; 21 21 - } 22 22 - }; 23 23 - 24 24 - return debounced; 25 25 - } 26 26 - 27 27 - export function throttle<T extends (...args: Parameters<T>) => void>( 28 28 - fn: T, 29 29 - ms: number, 30 30 - ): T { 31 31 - let lastCall = 0; 32 32 - let timeoutId: ReturnType<typeof setTimeout> | null = null; 33 33 - 34 34 - return ((...args: Parameters<T>) => { 35 35 - const now = Date.now(); 36 36 - const remaining = ms - (now - lastCall); 37 37 - 38 38 - if (remaining <= 0) { 39 39 - if (timeoutId) { 40 40 - clearTimeout(timeoutId); 41 41 - timeoutId = null; 42 42 - } 43 43 - lastCall = now; 44 44 - fn(...args); 45 45 - } else if (!timeoutId) { 46 46 - timeoutId = setTimeout(() => { 47 47 - lastCall = Date.now(); 48 48 - timeoutId = null; 49 49 - fn(...args); 50 50 - }, remaining); 51 51 - } 52 52 - }) as T; 53 53 - } 54 54 - 55 55 - export function sleep(ms: number): Promise<void> { 56 56 - return new Promise((resolve) => setTimeout(resolve, ms)); 57 57 - } 58 58 - 59 59 - export async function retry<T>( 60 60 - fn: () => Promise<T>, 61 61 - options: { 62 62 - attempts?: number; 63 63 - delay?: number; 64 64 - backoff?: number; 65 65 - shouldRetry?: (error: unknown, attempt: number) => boolean; 66 66 - } = {}, 67 67 - ): Promise<T> { 68 68 - const { 69 69 - attempts = 3, 70 70 - delay = 1000, 71 71 - backoff = 2, 72 72 - shouldRetry = () => true, 73 73 - } = options; 74 74 - 75 75 - let lastError: unknown; 76 76 - let currentDelay = delay; 77 77 - 78 78 - for (let attempt = 1; attempt <= attempts; attempt++) { 79 79 - try { 80 80 - return await fn(); 81 81 - } catch (error) { 82 82 - lastError = error; 83 83 - if (attempt === attempts || !shouldRetry(error, attempt)) { 84 84 - throw error; 85 85 - } 86 86 - await sleep(currentDelay); 87 87 - currentDelay *= backoff; 88 88 - } 89 89 - } 90 90 - 91 91 - throw lastError; 92 92 - } 93 93 - 94 94 - export async function retryResult<T, E>( 95 95 - fn: () => Promise<Result<T, E>>, 96 96 - options: { 97 97 - attempts?: number; 98 98 - delay?: number; 99 99 - backoff?: number; 100 100 - shouldRetry?: (error: E, attempt: number) => boolean; 101 101 - } = {}, 102 102 - ): Promise<Result<T, E>> { 103 103 - const { 104 104 - attempts = 3, 105 105 - delay = 1000, 106 106 - backoff = 2, 107 107 - shouldRetry = () => true, 108 108 - } = options; 109 109 - 110 110 - let lastResult: Result<T, E> | null = null; 111 111 - let currentDelay = delay; 112 112 - 113 113 - for (let attempt = 1; attempt <= attempts; attempt++) { 114 114 - const result = await fn(); 115 115 - lastResult = result; 116 116 - 117 117 - if (result.ok) { 118 118 - return result; 119 119 - } 120 120 - 121 121 - if (attempt === attempts || !shouldRetry(result.error, attempt)) { 122 122 - return result; 123 123 - } 124 124 - 125 125 - await sleep(currentDelay); 126 126 - currentDelay *= backoff; 127 127 - } 128 128 - 129 129 - return lastResult!; 130 130 - } 131 131 - 132 132 - export function timeout<T>(promise: Promise<T>, ms: number): Promise<T> { 133 133 - return new Promise((resolve, reject) => { 134 134 - const timeoutId = setTimeout(() => { 135 135 - reject(new Error(`Timeout after ${ms}ms`)); 136 136 - }, ms); 137 137 - 138 138 - promise 139 139 - .then((value) => { 140 140 - clearTimeout(timeoutId); 141 141 - resolve(value); 142 142 - }) 143 143 - .catch((error) => { 144 144 - clearTimeout(timeoutId); 145 145 - reject(error); 146 146 - }); 147 147 - }); 148 148 - } 149 149 - 150 150 - export async function timeoutResult<T>( 151 151 - promise: Promise<Result<T, Error>>, 152 152 - ms: number, 153 153 - ): Promise<Result<T, Error>> { 154 154 - try { 155 155 - return await timeout(promise, ms); 156 156 - } catch (e) { 157 157 - return err(e instanceof Error ? e : new Error(String(e))); 158 158 - } 159 159 - } 160 160 - 161 161 - export async function parallel<T>( 162 162 - tasks: (() => Promise<T>)[], 163 163 - concurrency: number, 164 164 - ): Promise<T[]> { 165 165 - const results: T[] = []; 166 166 - const executing: Promise<void>[] = []; 167 167 - 168 168 - for (const task of tasks) { 169 169 - const p = task().then((result) => { 170 170 - results.push(result); 171 171 - }); 172 172 - 173 173 - executing.push(p); 174 174 - 175 175 - if (executing.length >= concurrency) { 176 176 - await Promise.race(executing); 177 177 - executing.splice( 178 178 - executing.findIndex((e) => e === p), 179 179 - 1, 180 180 - ); 181 181 - } 182 182 - } 183 183 - 184 184 - await Promise.all(executing); 185 185 - return results; 186 186 - } 187 187 - 188 188 - export async function mapParallel<T, U>( 189 189 - items: T[], 190 190 - fn: (item: T, index: number) => Promise<U>, 191 191 - concurrency: number, 192 192 - ): Promise<U[]> { 193 193 - const results: U[] = new Array(items.length); 194 194 - const executing: Promise<void>[] = []; 195 195 - 196 196 - for (let i = 0; i < items.length; i++) { 197 197 - const index = i; 198 198 - const p = fn(items[index], index).then((result) => { 199 199 - results[index] = result; 200 200 - }); 201 201 - 202 202 - executing.push(p); 203 203 - 204 204 - if (executing.length >= concurrency) { 205 205 - await Promise.race(executing); 206 206 - const doneIndex = executing.findIndex( 207 207 - (e) => (e as Promise<void> & { _done?: boolean })._done !== false, 208 208 - ); 209 209 - if (doneIndex >= 0) { 210 210 - executing.splice(doneIndex, 1); 211 211 - } 212 212 - } 213 213 - } 214 214 - 215 215 - await Promise.all(executing); 216 216 - return results; 217 217 - } 218 218 - 219 219 - export function createAbortable<T>( 220 220 - fn: (signal: AbortSignal) => Promise<T>, 221 221 - ): { promise: Promise<T>; abort: () => void } { 222 222 - const controller = new AbortController(); 223 223 - return { 224 224 - promise: fn(controller.signal), 225 225 - abort: () => controller.abort(), 226 226 - }; 227 227 - } 228 228 - 229 229 - export interface Deferred<T> { 230 230 - promise: Promise<T>; 231 231 - resolve: (value: T) => void; 232 232 - reject: (error: unknown) => void; 233 233 - } 234 234 - 235 235 - export function deferred<T>(): Deferred<T> { 236 236 - let resolve!: (value: T) => void; 237 237 - let reject!: (error: unknown) => void; 238 238 - 239 239 - const promise = new Promise<T>((res, rej) => { 240 240 - resolve = res; 241 241 - reject = rej; 242 242 - }); 243 243 - 244 244 - return { promise, resolve, reject }; 245 245 - }

-27

frontend/src/lib/utils/index.ts

··· 1 1 - export * from "./option.ts"; 2 2 - export { 3 3 - at, 4 4 - chunk, 5 5 - find, 6 6 - findIndex, 7 7 - findMap, 8 8 - first, 9 9 - groupBy, 10 10 - intersperse, 11 11 - isEmpty, 12 12 - isNonEmpty, 13 13 - last, 14 14 - maxBy, 15 15 - minBy, 16 16 - partition, 17 17 - range, 18 18 - sortBy, 19 19 - sortByDesc, 20 20 - sum, 21 21 - sumBy, 22 22 - unique, 23 23 - uniqueBy, 24 24 - zip as zipArrays, 25 25 - zipWith as zipArraysWith, 26 26 - } from "./array.ts"; 27 27 - export * from "./async.ts";

-85

frontend/src/lib/utils/option.ts

··· 1 1 - export type Option<T> = T | null | undefined; 2 2 - 3 3 - export function isSome<T>(opt: Option<T>): opt is T { 4 4 - return opt != null; 5 5 - } 6 6 - 7 7 - export function isNone<T>(opt: Option<T>): opt is null | undefined { 8 8 - return opt == null; 9 9 - } 10 10 - 11 11 - export function map<T, U>(opt: Option<T>, fn: (t: T) => U): Option<U> { 12 12 - return isSome(opt) ? fn(opt) : null; 13 13 - } 14 14 - 15 15 - export function flatMap<T, U>( 16 16 - opt: Option<T>, 17 17 - fn: (t: T) => Option<U>, 18 18 - ): Option<U> { 19 19 - return isSome(opt) ? fn(opt) : null; 20 20 - } 21 21 - 22 22 - export function filter<T>( 23 23 - opt: Option<T>, 24 24 - predicate: (t: T) => boolean, 25 25 - ): Option<T> { 26 26 - return isSome(opt) && predicate(opt) ? opt : null; 27 27 - } 28 28 - 29 29 - export function getOrElse<T>(opt: Option<T>, defaultValue: T): T { 30 30 - return isSome(opt) ? opt : defaultValue; 31 31 - } 32 32 - 33 33 - export function getOrElseLazy<T>(opt: Option<T>, fn: () => T): T { 34 34 - return isSome(opt) ? opt : fn(); 35 35 - } 36 36 - 37 37 - export function getOrThrow<T>(opt: Option<T>, error?: string | Error): T { 38 38 - if (isSome(opt)) return opt; 39 39 - if (error instanceof Error) throw error; 40 40 - throw new Error(error ?? "Expected value but got null/undefined"); 41 41 - } 42 42 - 43 43 - export function tap<T>(opt: Option<T>, fn: (t: T) => void): Option<T> { 44 44 - if (isSome(opt)) fn(opt); 45 45 - return opt; 46 46 - } 47 47 - 48 48 - export function match<T, U>( 49 49 - opt: Option<T>, 50 50 - handlers: { some: (t: T) => U; none: () => U }, 51 51 - ): U { 52 52 - return isSome(opt) ? handlers.some(opt) : handlers.none(); 53 53 - } 54 54 - 55 55 - export function toArray<T>(opt: Option<T>): T[] { 56 56 - return isSome(opt) ? [opt] : []; 57 57 - } 58 58 - 59 59 - export function fromArray<T>(arr: T[]): Option<T> { 60 60 - return arr.length > 0 ? arr[0] : null; 61 61 - } 62 62 - 63 63 - export function zip<T, U>(a: Option<T>, b: Option<U>): Option<[T, U]> { 64 64 - return isSome(a) && isSome(b) ? [a, b] : null; 65 65 - } 66 66 - 67 67 - export function zipWith<T, U, R>( 68 68 - a: Option<T>, 69 69 - b: Option<U>, 70 70 - fn: (t: T, u: U) => R, 71 71 - ): Option<R> { 72 72 - return isSome(a) && isSome(b) ? fn(a, b) : null; 73 73 - } 74 74 - 75 75 - export function or<T>(a: Option<T>, b: Option<T>): Option<T> { 76 76 - return isSome(a) ? a : b; 77 77 - } 78 78 - 79 79 - export function orLazy<T>(a: Option<T>, fn: () => Option<T>): Option<T> { 80 80 - return isSome(a) ? a : fn(); 81 81 - } 82 82 - 83 83 - export function and<T, U>(a: Option<T>, b: Option<U>): Option<U> { 84 84 - return isSome(a) ? b : null; 85 85 - }

-286

frontend/src/lib/validation.ts

··· 1 1 - import { err, ok, type Result } from "./types/result.ts"; 2 2 - import { 3 3 - type AtUri, 4 4 - type Cid, 5 5 - type Did, 6 6 - type DidPlc, 7 7 - type DidWeb, 8 8 - type EmailAddress, 9 9 - type Handle, 10 10 - isAtUri, 11 11 - isCid, 12 12 - isDid, 13 13 - isDidPlc, 14 14 - isDidWeb, 15 15 - isEmail, 16 16 - isHandle, 17 17 - isISODate, 18 18 - isNsid, 19 19 - type ISODateString, 20 20 - type Nsid, 21 21 - } from "./types/branded.ts"; 22 22 - 23 23 - export class ValidationError extends Error { 24 24 - constructor( 25 25 - message: string, 26 26 - public readonly field?: string, 27 27 - public readonly value?: unknown, 28 28 - ) { 29 29 - super(message); 30 30 - this.name = "ValidationError"; 31 31 - } 32 32 - } 33 33 - 34 34 - export function parseDid(s: string): Result<Did, ValidationError> { 35 35 - if (isDid(s)) { 36 36 - return ok(s); 37 37 - } 38 38 - return err(new ValidationError(`Invalid DID: ${s}`, "did", s)); 39 39 - } 40 40 - 41 41 - export function parseDidPlc(s: string): Result<DidPlc, ValidationError> { 42 42 - if (isDidPlc(s)) { 43 43 - return ok(s); 44 44 - } 45 45 - return err(new ValidationError(`Invalid DID:PLC: ${s}`, "did", s)); 46 46 - } 47 47 - 48 48 - export function parseDidWeb(s: string): Result<DidWeb, ValidationError> { 49 49 - if (isDidWeb(s)) { 50 50 - return ok(s); 51 51 - } 52 52 - return err(new ValidationError(`Invalid DID:WEB: ${s}`, "did", s)); 53 53 - } 54 54 - 55 55 - export function parseHandle(s: string): Result<Handle, ValidationError> { 56 56 - const trimmed = s.trim().toLowerCase(); 57 57 - if (isHandle(trimmed)) { 58 58 - return ok(trimmed); 59 59 - } 60 60 - return err(new ValidationError(`Invalid handle: ${s}`, "handle", s)); 61 61 - } 62 62 - 63 63 - export function parseEmail(s: string): Result<EmailAddress, ValidationError> { 64 64 - const trimmed = s.trim().toLowerCase(); 65 65 - if (isEmail(trimmed)) { 66 66 - return ok(trimmed); 67 67 - } 68 68 - return err(new ValidationError(`Invalid email: ${s}`, "email", s)); 69 69 - } 70 70 - 71 71 - export function parseAtUri(s: string): Result<AtUri, ValidationError> { 72 72 - if (isAtUri(s)) { 73 73 - return ok(s); 74 74 - } 75 75 - return err(new ValidationError(`Invalid AT-URI: ${s}`, "uri", s)); 76 76 - } 77 77 - 78 78 - export function parseCid(s: string): Result<Cid, ValidationError> { 79 79 - if (isCid(s)) { 80 80 - return ok(s); 81 81 - } 82 82 - return err(new ValidationError(`Invalid CID: ${s}`, "cid", s)); 83 83 - } 84 84 - 85 85 - export function parseNsid(s: string): Result<Nsid, ValidationError> { 86 86 - if (isNsid(s)) { 87 87 - return ok(s); 88 88 - } 89 89 - return err(new ValidationError(`Invalid NSID: ${s}`, "nsid", s)); 90 90 - } 91 91 - 92 92 - export function parseISODate( 93 93 - s: string, 94 94 - ): Result<ISODateString, ValidationError> { 95 95 - if (isISODate(s)) { 96 96 - return ok(s); 97 97 - } 98 98 - return err(new ValidationError(`Invalid ISO date: ${s}`, "date", s)); 99 99 - } 100 100 - 101 101 - export interface PasswordValidationResult { 102 102 - valid: boolean; 103 103 - errors: string[]; 104 104 - strength: "weak" | "fair" | "good" | "strong"; 105 105 - } 106 106 - 107 107 - export function validatePassword(password: string): PasswordValidationResult { 108 108 - const errors: string[] = []; 109 109 - 110 110 - if (password.length < 8) { 111 111 - errors.push("Password must be at least 8 characters"); 112 112 - } 113 113 - if (password.length > 256) { 114 114 - errors.push("Password must be at most 256 characters"); 115 115 - } 116 116 - if (!/[a-z]/.test(password)) { 117 117 - errors.push("Password must contain a lowercase letter"); 118 118 - } 119 119 - if (!/[A-Z]/.test(password)) { 120 120 - errors.push("Password must contain an uppercase letter"); 121 121 - } 122 122 - if (!/\d/.test(password)) { 123 123 - errors.push("Password must contain a number"); 124 124 - } 125 125 - 126 126 - let strength: PasswordValidationResult["strength"] = "weak"; 127 127 - if (errors.length === 0) { 128 128 - const hasSpecial = /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password); 129 129 - const isLong = password.length >= 12; 130 130 - const isVeryLong = password.length >= 16; 131 131 - 132 132 - if (isVeryLong && hasSpecial) { 133 133 - strength = "strong"; 134 134 - } else if (isLong || hasSpecial) { 135 135 - strength = "good"; 136 136 - } else { 137 137 - strength = "fair"; 138 138 - } 139 139 - } 140 140 - 141 141 - return { 142 142 - valid: errors.length === 0, 143 143 - errors, 144 144 - strength, 145 145 - }; 146 146 - } 147 147 - 148 148 - export function validateHandle( 149 149 - handle: string, 150 150 - ): Result<Handle, ValidationError> { 151 151 - const trimmed = handle.trim().toLowerCase(); 152 152 - 153 153 - if (trimmed.length < 3) { 154 154 - return err( 155 155 - new ValidationError( 156 156 - "Handle must be at least 3 characters", 157 157 - "handle", 158 158 - handle, 159 159 - ), 160 160 - ); 161 161 - } 162 162 - 163 163 - if (trimmed.length > 253) { 164 164 - return err( 165 165 - new ValidationError( 166 166 - "Handle must be at most 253 characters", 167 167 - "handle", 168 168 - handle, 169 169 - ), 170 170 - ); 171 171 - } 172 172 - 173 173 - if (!isHandle(trimmed)) { 174 174 - return err(new ValidationError("Invalid handle format", "handle", handle)); 175 175 - } 176 176 - 177 177 - return ok(trimmed); 178 178 - } 179 179 - 180 180 - export function validateInviteCode( 181 181 - code: string, 182 182 - ): Result<string, ValidationError> { 183 183 - const trimmed = code.trim(); 184 184 - 185 185 - if (trimmed.length === 0) { 186 186 - return err( 187 187 - new ValidationError("Invite code is required", "inviteCode", code), 188 188 - ); 189 189 - } 190 190 - 191 191 - const pattern = /^[a-zA-Z0-9-]+$/; 192 192 - if (!pattern.test(trimmed)) { 193 193 - return err( 194 194 - new ValidationError("Invalid invite code format", "inviteCode", code), 195 195 - ); 196 196 - } 197 197 - 198 198 - return ok(trimmed); 199 199 - } 200 200 - 201 201 - export function validateTotpCode( 202 202 - code: string, 203 203 - ): Result<string, ValidationError> { 204 204 - const trimmed = code.trim().replace(/\s/g, ""); 205 205 - 206 206 - if (!/^\d{6}$/.test(trimmed)) { 207 207 - return err(new ValidationError("TOTP code must be 6 digits", "code", code)); 208 208 - } 209 209 - 210 210 - return ok(trimmed); 211 211 - } 212 212 - 213 213 - export function validateBackupCode( 214 214 - code: string, 215 215 - ): Result<string, ValidationError> { 216 216 - const trimmed = code.trim().replace(/\s/g, "").toLowerCase(); 217 217 - 218 218 - if (!/^[a-z0-9]{8}$/.test(trimmed)) { 219 219 - return err(new ValidationError("Invalid backup code format", "code", code)); 220 220 - } 221 221 - 222 222 - return ok(trimmed); 223 223 - } 224 224 - 225 225 - export interface FormValidation<T> { 226 226 - validate: () => Result<T, ValidationError[]>; 227 227 - field: <K extends keyof T>( 228 228 - key: K, 229 229 - validator: (value: unknown) => Result<T[K], ValidationError>, 230 230 - ) => FormValidation<T>; 231 231 - optional: <K extends keyof T>( 232 232 - key: K, 233 233 - validator: (value: unknown) => Result<T[K], ValidationError>, 234 234 - ) => FormValidation<T>; 235 235 - } 236 236 - 237 237 - export function createFormValidation<T extends Record<string, unknown>>( 238 238 - data: Record<string, unknown>, 239 239 - ): FormValidation<T> { 240 240 - const validators: Array<{ 241 241 - key: string; 242 242 - validator: (value: unknown) => Result<unknown, ValidationError>; 243 243 - optional: boolean; 244 244 - }> = []; 245 245 - 246 246 - const builder: FormValidation<T> = { 247 247 - field: (key, validator) => { 248 248 - validators.push({ key: key as string, validator, optional: false }); 249 249 - return builder; 250 250 - }, 251 251 - optional: (key, validator) => { 252 252 - validators.push({ key: key as string, validator, optional: true }); 253 253 - return builder; 254 254 - }, 255 255 - validate: () => { 256 256 - const errors: ValidationError[] = []; 257 257 - const result: Record<string, unknown> = {}; 258 258 - 259 259 - for (const { key, validator, optional } of validators) { 260 260 - const value = data[key]; 261 261 - 262 262 - if (value == null || value === "") { 263 263 - if (!optional) { 264 264 - errors.push(new ValidationError(`${key} is required`, key)); 265 265 - } 266 266 - continue; 267 267 - } 268 268 - 269 269 - const validated = validator(value); 270 270 - if (validated.ok) { 271 271 - result[key] = validated.value; 272 272 - } else { 273 273 - errors.push(validated.error); 274 274 - } 275 275 - } 276 276 - 277 277 - if (errors.length > 0) { 278 278 - return err(errors); 279 279 - } 280 280 - 281 281 - return ok(result as T); 282 282 - }, 283 283 - }; 284 284 - 285 285 - return builder; 286 286 - }

-255

frontend/src/tests/migration/atproto-client.test.ts

··· 1 1 import { beforeEach, describe, expect, it, vi } from "vitest"; 2 2 import { 3 3 AtprotoClient, 4 4 - base64UrlDecode, 5 5 - base64UrlEncode, 6 4 buildOAuthAuthorizationUrl, 7 5 clearDPoPKey, 8 6 generateDPoPKeyPair, 9 9 - generateOAuthState, 10 10 - generatePKCE, 11 7 getMigrationOAuthClientId, 12 8 getMigrationOAuthRedirectUri, 13 9 loadDPoPKey, 14 14 - prepareWebAuthnCreationOptions, 15 10 saveDPoPKey, 16 11 } from "../../lib/migration/atproto-client.ts"; 17 12 import type { OAuthServerMetadata } from "../../lib/migration/types.ts"; ··· 23 18 localStorage.removeItem(DPOP_KEY_STORAGE); 24 19 }); 25 20 26 26 - describe("base64UrlEncode", () => { 27 27 - it("encodes empty buffer", () => { 28 28 - const result = base64UrlEncode(new Uint8Array([])); 29 29 - expect(result).toBe(""); 30 30 - }); 31 31 - 32 32 - it("encodes simple data", () => { 33 33 - const data = new TextEncoder().encode("hello"); 34 34 - const result = base64UrlEncode(data); 35 35 - expect(result).toBe("aGVsbG8"); 36 36 - }); 37 37 - 38 38 - it("uses URL-safe characters (no +, /, or =)", () => { 39 39 - const data = new Uint8Array([251, 255, 254]); 40 40 - const result = base64UrlEncode(data); 41 41 - expect(result).not.toContain("+"); 42 42 - expect(result).not.toContain("/"); 43 43 - expect(result).not.toContain("="); 44 44 - }); 45 45 - 46 46 - it("replaces + with -", () => { 47 47 - const data = new Uint8Array([251]); 48 48 - const result = base64UrlEncode(data); 49 49 - expect(result).toContain("-"); 50 50 - }); 51 51 - 52 52 - it("replaces / with _", () => { 53 53 - const data = new Uint8Array([255]); 54 54 - const result = base64UrlEncode(data); 55 55 - expect(result).toContain("_"); 56 56 - }); 57 57 - 58 58 - it("accepts ArrayBuffer", () => { 59 59 - const arrayBuffer = new ArrayBuffer(4); 60 60 - const view = new Uint8Array(arrayBuffer); 61 61 - view[0] = 116; // t 62 62 - view[1] = 101; // e 63 63 - view[2] = 115; // s 64 64 - view[3] = 116; // t 65 65 - const result = base64UrlEncode(arrayBuffer); 66 66 - expect(result).toBe("dGVzdA"); 67 67 - }); 68 68 - }); 69 69 - 70 70 - describe("base64UrlDecode", () => { 71 71 - it("decodes empty string", () => { 72 72 - const result = base64UrlDecode(""); 73 73 - expect(result.length).toBe(0); 74 74 - }); 75 75 - 76 76 - it("decodes URL-safe base64", () => { 77 77 - const result = base64UrlDecode("aGVsbG8"); 78 78 - expect(new TextDecoder().decode(result)).toBe("hello"); 79 79 - }); 80 80 - 81 81 - it("handles - and _ characters", () => { 82 82 - const encoded = base64UrlEncode(new Uint8Array([251, 255, 254])); 83 83 - const decoded = base64UrlDecode(encoded); 84 84 - expect(decoded).toEqual(new Uint8Array([251, 255, 254])); 85 85 - }); 86 86 - 87 87 - it("is inverse of base64UrlEncode", () => { 88 88 - const original = new Uint8Array([0, 1, 2, 255, 254, 253]); 89 89 - const encoded = base64UrlEncode(original); 90 90 - const decoded = base64UrlDecode(encoded); 91 91 - expect(decoded).toEqual(original); 92 92 - }); 93 93 - 94 94 - it("handles missing padding", () => { 95 95 - const result = base64UrlDecode("YQ"); 96 96 - expect(new TextDecoder().decode(result)).toBe("a"); 97 97 - }); 98 98 - }); 99 99 - 100 100 - describe("generateOAuthState", () => { 101 101 - it("generates a non-empty string", () => { 102 102 - const state = generateOAuthState(); 103 103 - expect(state).toBeTruthy(); 104 104 - expect(typeof state).toBe("string"); 105 105 - }); 106 106 - 107 107 - it("generates URL-safe characters only", () => { 108 108 - const state = generateOAuthState(); 109 109 - expect(state).toMatch(/^[A-Za-z0-9_-]+$/); 110 110 - }); 111 111 - 112 112 - it("generates different values each time", () => { 113 113 - const state1 = generateOAuthState(); 114 114 - const state2 = generateOAuthState(); 115 115 - expect(state1).not.toBe(state2); 116 116 - }); 117 117 - }); 118 118 - 119 119 - describe("generatePKCE", () => { 120 120 - it("generates code_verifier and code_challenge", async () => { 121 121 - const pkce = await generatePKCE(); 122 122 - expect(pkce.codeVerifier).toBeTruthy(); 123 123 - expect(pkce.codeChallenge).toBeTruthy(); 124 124 - }); 125 125 - 126 126 - it("generates URL-safe code_verifier", async () => { 127 127 - const pkce = await generatePKCE(); 128 128 - expect(pkce.codeVerifier).toMatch(/^[A-Za-z0-9_-]+$/); 129 129 - }); 130 130 - 131 131 - it("generates URL-safe code_challenge", async () => { 132 132 - const pkce = await generatePKCE(); 133 133 - expect(pkce.codeChallenge).toMatch(/^[A-Za-z0-9_-]+$/); 134 134 - }); 135 135 - 136 136 - it("code_challenge is SHA-256 hash of code_verifier", async () => { 137 137 - const pkce = await generatePKCE(); 138 138 - 139 139 - const encoder = new TextEncoder(); 140 140 - const data = encoder.encode(pkce.codeVerifier); 141 141 - const digest = await crypto.subtle.digest("SHA-256", data); 142 142 - const expectedChallenge = base64UrlEncode(new Uint8Array(digest)); 143 143 - 144 144 - expect(pkce.codeChallenge).toBe(expectedChallenge); 145 145 - }); 146 146 - 147 147 - it("generates different values each time", async () => { 148 148 - const pkce1 = await generatePKCE(); 149 149 - const pkce2 = await generatePKCE(); 150 150 - expect(pkce1.codeVerifier).not.toBe(pkce2.codeVerifier); 151 151 - expect(pkce1.codeChallenge).not.toBe(pkce2.codeChallenge); 152 152 - }); 153 153 - }); 154 154 - 155 21 describe("buildOAuthAuthorizationUrl", () => { 156 22 const mockMetadata: OAuthServerMetadata = { 157 23 issuer: "https://bsky.social", ··· 398 264 }); 399 265 }); 400 266 401 401 - describe("prepareWebAuthnCreationOptions", () => { 402 402 - it("decodes challenge from base64url", () => { 403 403 - const options = { 404 404 - publicKey: { 405 405 - challenge: "dGVzdC1jaGFsbGVuZ2U", 406 406 - user: { 407 407 - id: "dXNlci1pZA", 408 408 - name: "test@example.com", 409 409 - displayName: "Test User", 410 410 - }, 411 411 - excludeCredentials: [], 412 412 - rp: { name: "Test" }, 413 413 - pubKeyCredParams: [{ type: "public-key", alg: -7 }], 414 414 - }, 415 415 - }; 416 416 - 417 417 - const prepared = prepareWebAuthnCreationOptions(options); 418 418 - 419 419 - expect(prepared.challenge).toBeInstanceOf(Uint8Array); 420 420 - expect(new TextDecoder().decode(prepared.challenge as Uint8Array)).toBe( 421 421 - "test-challenge", 422 422 - ); 423 423 - }); 424 424 - 425 425 - it("decodes user.id from base64url", () => { 426 426 - const options = { 427 427 - publicKey: { 428 428 - challenge: "Y2hhbGxlbmdl", 429 429 - user: { 430 430 - id: "dXNlci1pZA", 431 431 - name: "test@example.com", 432 432 - displayName: "Test User", 433 433 - }, 434 434 - excludeCredentials: [], 435 435 - rp: { name: "Test" }, 436 436 - pubKeyCredParams: [{ type: "public-key", alg: -7 }], 437 437 - }, 438 438 - }; 439 439 - 440 440 - const prepared = prepareWebAuthnCreationOptions(options); 441 441 - 442 442 - expect(prepared.user?.id).toBeInstanceOf(Uint8Array); 443 443 - expect(new TextDecoder().decode(prepared.user?.id as Uint8Array)).toBe( 444 444 - "user-id", 445 445 - ); 446 446 - }); 447 447 - 448 448 - it("decodes excludeCredentials ids from base64url", () => { 449 449 - const options = { 450 450 - publicKey: { 451 451 - challenge: "Y2hhbGxlbmdl", 452 452 - user: { 453 453 - id: "dXNlcg", 454 454 - name: "test@example.com", 455 455 - displayName: "Test User", 456 456 - }, 457 457 - excludeCredentials: [ 458 458 - { id: "Y3JlZDE", type: "public-key" }, 459 459 - { id: "Y3JlZDI", type: "public-key" }, 460 460 - ], 461 461 - rp: { name: "Test" }, 462 462 - pubKeyCredParams: [{ type: "public-key", alg: -7 }], 463 463 - }, 464 464 - }; 465 465 - 466 466 - const prepared = prepareWebAuthnCreationOptions(options); 467 467 - 468 468 - expect(prepared.excludeCredentials).toHaveLength(2); 469 469 - expect( 470 470 - new TextDecoder().decode( 471 471 - prepared.excludeCredentials![0].id as Uint8Array, 472 472 - ), 473 473 - ).toBe("cred1"); 474 474 - expect( 475 475 - new TextDecoder().decode( 476 476 - prepared.excludeCredentials![1].id as Uint8Array, 477 477 - ), 478 478 - ).toBe("cred2"); 479 479 - }); 480 480 - 481 481 - it("handles empty excludeCredentials", () => { 482 482 - const options = { 483 483 - publicKey: { 484 484 - challenge: "Y2hhbGxlbmdl", 485 485 - user: { 486 486 - id: "dXNlcg", 487 487 - name: "test@example.com", 488 488 - displayName: "Test User", 489 489 - }, 490 490 - rp: { name: "Test" }, 491 491 - pubKeyCredParams: [{ type: "public-key", alg: -7 }], 492 492 - }, 493 493 - }; 494 494 - 495 495 - const prepared = prepareWebAuthnCreationOptions(options); 496 496 - 497 497 - expect(prepared.excludeCredentials).toEqual([]); 498 498 - }); 499 499 - 500 500 - it("preserves other user properties", () => { 501 501 - const options = { 502 502 - publicKey: { 503 503 - challenge: "Y2hhbGxlbmdl", 504 504 - user: { 505 505 - id: "dXNlcg", 506 506 - name: "test@example.com", 507 507 - displayName: "Test User", 508 508 - }, 509 509 - excludeCredentials: [], 510 510 - rp: { name: "Test" }, 511 511 - pubKeyCredParams: [{ type: "public-key", alg: -7 }], 512 512 - }, 513 513 - }; 514 514 - 515 515 - const prepared = prepareWebAuthnCreationOptions(options); 516 516 - 517 517 - expect(prepared.user?.name).toBe("test@example.com"); 518 518 - expect(prepared.user?.displayName).toBe("Test User"); 519 519 - }); 520 520 - }); 521 521 - 522 267 describe("AtprotoClient.verifyHandleOwnership", () => { 523 268 function createMockJsonResponse(data: unknown, status = 200) { 524 269 return new Response(JSON.stringify(data), {

+5 -2

frontend/src/tests/migration/storage.test.ts

··· 88 88 generatedAppPasswordName: null, 89 89 handlePreservation: "new", 90 90 existingHandleVerified: false, 91 91 + verificationChannel: "email", 92 92 + discordUsername: "", 93 93 + telegramUsername: "", 94 94 + signalUsername: "", 91 95 ...overrides, 92 96 }; 93 97 } ··· 130 134 131 135 describe("migration/storage", () => { 132 136 beforeEach(() => { 133 133 - localStorage.removeItem(STORAGE_KEY); 134 134 - localStorage.removeItem(DPOP_KEY_STORAGE); 137 137 + localStorage.clear(); 135 138 }); 136 139 137 140 describe("saveMigrationState", () => {

+2 -2

frontend/src/tests/oauth-registration.test.ts

··· 218 218 }); 219 219 220 220 const RegisterPassword = 221 221 - (await import("../routes/RegisterPassword.svelte")).default; 221 221 + (await import("../routes/Register.svelte")).default; 222 222 render(RegisterPassword); 223 223 224 224 await waitFor( ··· 253 253 ); 254 254 255 255 const RegisterPassword = 256 256 - (await import("../routes/RegisterPassword.svelte")).default; 256 256 + (await import("../routes/Register.svelte")).default; 257 257 render(RegisterPassword); 258 258 259 259 await waitFor(() => {

-97

frontend/src/tests/utils.ts

··· 1 1 - import { render } from "@testing-library/svelte"; 2 2 - import { tick } from "svelte"; 3 3 - import type { ComponentType } from "svelte"; 4 4 - 5 5 - export async function renderAndWait( 6 6 - component: ComponentType, 7 7 - options?: Parameters<typeof render>[1], 8 8 - ) { 9 9 - const result = render(component, options); 10 10 - await tick(); 11 11 - await new Promise((resolve) => setTimeout(resolve, 0)); 12 12 - return result; 13 13 - } 14 14 - 15 15 - export async function waitForElement( 16 16 - queryFn: () => HTMLElement | null, 17 17 - timeout = 1000, 18 18 - ): Promise<HTMLElement> { 19 19 - const start = Date.now(); 20 20 - while (Date.now() - start < timeout) { 21 21 - const element = queryFn(); 22 22 - if (element) return element; 23 23 - await new Promise((resolve) => setTimeout(resolve, 10)); 24 24 - } 25 25 - throw new Error("Element not found within timeout"); 26 26 - } 27 27 - 28 28 - export async function waitForElementToDisappear( 29 29 - queryFn: () => HTMLElement | null, 30 30 - timeout = 1000, 31 31 - ): Promise<void> { 32 32 - const start = Date.now(); 33 33 - while (Date.now() - start < timeout) { 34 34 - const element = queryFn(); 35 35 - if (!element) return; 36 36 - await new Promise((resolve) => setTimeout(resolve, 10)); 37 37 - } 38 38 - throw new Error("Element still present after timeout"); 39 39 - } 40 40 - 41 41 - export async function waitForText( 42 42 - container: HTMLElement, 43 43 - text: string | RegExp, 44 44 - timeout = 1000, 45 45 - ): Promise<void> { 46 46 - const start = Date.now(); 47 47 - while (Date.now() - start < timeout) { 48 48 - const content = container.textContent || ""; 49 49 - if ( 50 50 - typeof text === "string" ? content.includes(text) : text.test(content) 51 51 - ) { 52 52 - return; 53 53 - } 54 54 - await new Promise((resolve) => setTimeout(resolve, 10)); 55 55 - } 56 56 - throw new Error(`Text "${text}" not found within timeout`); 57 57 - } 58 58 - 59 59 - export function mockLocalStorage( 60 60 - initialData: Record<string, string> = {}, 61 61 - ): void { 62 62 - const store: Record<string, string> = { ...initialData }; 63 63 - Object.defineProperty(window, "localStorage", { 64 64 - value: { 65 65 - getItem: (key: string) => store[key] || null, 66 66 - setItem: (key: string, value: string) => { 67 67 - store[key] = value; 68 68 - }, 69 69 - removeItem: (key: string) => { 70 70 - delete store[key]; 71 71 - }, 72 72 - clear: () => { 73 73 - Object.keys(store).forEach((key) => delete store[key]); 74 74 - }, 75 75 - key: (index: number) => Object.keys(store)[index] || null, 76 76 - get length() { 77 77 - return Object.keys(store).length; 78 78 - }, 79 79 - }, 80 80 - writable: true, 81 81 - }); 82 82 - } 83 83 - 84 84 - export function setAuthState(session: { 85 85 - did: string; 86 86 - handle: string; 87 87 - email?: string; 88 88 - emailConfirmed?: boolean; 89 89 - accessJwt: string; 90 90 - refreshJwt: string; 91 91 - }): void { 92 92 - localStorage.setItem("session", JSON.stringify(session)); 93 93 - } 94 94 - 95 95 - export function clearAuthState(): void { 96 96 - localStorage.removeItem("session"); 97 97 - }