Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
28 changes: 8 additions & 20 deletions Frontend/src/FrontendLogic/GameLogicFrontend.ts
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
import type { Game } from '../../../Backend/Steam'
import { BACKEND_URL } from './LogicConnection'
import { OrNull, ReadStored, RemoveStored, WriteStored } from './Storage'

interface GraphQLResponse<T> {
data?: T
Expand Down Expand Up @@ -57,33 +58,20 @@ function GameByIdCacheKey(appid: number): string {
}

function ReadCachedGames(key: string): Game[] | null {
try {
const rawCache = globalThis.localStorage?.getItem(key)
if (!rawCache) return null

const cache: unknown = JSON.parse(rawCache)
const age = Date.now() - (IsCachedGames(cache) ? cache.fetchedAt : 0)
if (IsCachedGames(cache) && age >= 0 && age < CACHE_TTL_MS) {
return cache.games
}
const cache = ReadStored<CachedGames | null>(key, null, OrNull(IsCachedGames), 'local')
if (!cache) return null

globalThis.localStorage.removeItem(key)
} catch (error) {
console.warn('Unable to read games from localStorage; fetching from the database.', error)
const age = Date.now() - (IsCachedGames(cache) ? cache.fetchedAt : 0)
if (IsCachedGames(cache) && age >= 0 && age < CACHE_TTL_MS) {
return cache.games
}

RemoveStored(key, 'local')
return null
}

function WriteCachedGames(key: string, games: Game[]): void {
try {
globalThis.localStorage?.setItem(
key,
JSON.stringify({ fetchedAt: Date.now(), games } satisfies CachedGames)
)
} catch (error) {
console.warn('Unable to cache games in localStorage.', error)
}
WriteStored(key, { fetchedAt: Date.now(), games } satisfies CachedGames, 'local')
}

function FindCachedGameById(appid: number): Game | null {
Expand Down
73 changes: 23 additions & 50 deletions Frontend/src/FrontendLogic/MainPageLogicFrontend.ts
Original file line number Diff line number Diff line change
@@ -1,95 +1,68 @@
import { Gql } from './LogicConnection'
import { type Game } from '../../../Backend/Steam'
import { IsBoolean, IsInteger, IsString, ReadStored, WriteStored } from '../FrontendLogic/Storage'

export type MainPageGenreSection = 'top10' | 'discounts'

const GAME_FIELDS = `appid name price initialprice discount img genre description`
const DISCOUNT_ONLY_KEY = 'GameStart:discountedOnlySearchpage'
const RECENT_REVIEW_KEY = 'GameStart:recentReviewCountMainpage'
const DEFAULT_REVIEW_COUNT = 3

const mainPageGenreStorageKeys: Record<MainPageGenreSection, string> = {
top10: 'GameStart:genreMainpage:top10',
discounts: 'GameStart:genreMainpage:discounts'
}

const discountedOnlyStorageKey = 'GameStart:discountedOnlySearchpage'
const recentReviewCountStorageKey = 'GameStart:recentReviewCountMainpage'
const defaultRecentReviewCount = 3

function ReportStorageError(action: string, error: unknown) {
const message = error instanceof Error ? error.message : String(error)
console.error(`MainPage: Could not ${action} in session storage: ${message}`)
}

export function GetSavedMainPageGenre(section: MainPageGenreSection): string {
try {
const parsed = JSON.parse(sessionStorage.getItem(mainPageGenreStorageKeys[section]) ?? '""')
return typeof parsed === 'string' ? parsed : ''
} catch (error: unknown) {
ReportStorageError('read the saved genre', error)
return ''
}
return ReadStored(mainPageGenreStorageKeys[section], '', IsString, 'session', (error) =>
ReportStorageError('Could not read the genre:', error)
)
}

export function SaveMainPageGenre(section: MainPageGenreSection, genre: string) {
try {
sessionStorage.setItem(mainPageGenreStorageKeys[section], JSON.stringify(genre))
} catch (error: unknown) {
ReportStorageError('save the genre', error)
}
WriteStored(mainPageGenreStorageKeys[section], genre)
}

export function GetDiscountedOnlySearchpage(): boolean {
try {
return JSON.parse(sessionStorage.getItem(discountedOnlyStorageKey) ?? 'false') === true
} catch (error: unknown) {
ReportStorageError('read the discounted-only filter', error)
return false
}
return ReadStored(DISCOUNT_ONLY_KEY, false, IsBoolean, 'session', (error) =>
ReportStorageError('Could not read discounted only games:', error))
}

export function SaveDiscountedOnlySearchpage(discountedOnly: boolean) {
try {
sessionStorage.setItem(discountedOnlyStorageKey, JSON.stringify(discountedOnly))
} catch (error: unknown) {
ReportStorageError('save the discounted-only filter', error)
}
WriteStored(DISCOUNT_ONLY_KEY, discountedOnly)
}

export function GetSavedRecentReviewCount(): number {
try {
const saved = sessionStorage.getItem(recentReviewCountStorageKey)
if (saved === null) return defaultRecentReviewCount

const parsed: unknown = JSON.parse(saved)
if (typeof parsed === 'number' && Number.isInteger(parsed) && parsed > 0) return parsed
return defaultRecentReviewCount
} catch (error: unknown) {
ReportStorageError('read the recent review count', error)
return defaultRecentReviewCount
}
return ReadStored(RECENT_REVIEW_KEY, DEFAULT_REVIEW_COUNT, IsInteger, 'session', (error) =>
ReportStorageError('Could not read recent review count: ', error))
}

export function SaveRecentReviewCount(count: number) {
try {
sessionStorage.setItem(recentReviewCountStorageKey, JSON.stringify(count))
} catch (error: unknown) {
ReportStorageError('save the recent review count', error)
}
WriteStored(RECENT_REVIEW_KEY, count)
}

export function PrepareDiscountGenreSearch(genre: string) {
const searchPageValues: Record<string, string> = {
'GameStart:filtersSearchpage': JSON.stringify(genre ? [genre] : []),
[discountedOnlyStorageKey]: JSON.stringify(true),
'GameStart:querySearchpage': JSON.stringify(''),
'GameStart:sortOptionSearchpage': JSON.stringify(''),
'GameStart:pageSearchpage': JSON.stringify(1)
const searchPageValues: Record<string, unknown> = {
'GameStart:filtersSearchpage': genre ? [genre] : [],
[DISCOUNT_ONLY_KEY]: true,
'GameStart:querySearchpage': '',
'GameStart:sortOptionSearchpage': '',
'GameStart:pageSearchpage': 1
}

try {
for (const [key, value] of Object.entries(searchPageValues)) {
sessionStorage.setItem(key, value)
WriteStored(key, value)
}
} catch (error: unknown) {
ReportStorageError('prepare the discounted genre search', error)
ReportStorageError('Prepare the discounted genre search', error)
}
}

Expand Down
94 changes: 17 additions & 77 deletions Frontend/src/FrontendLogic/SearchPageLogicFrontend.ts
Original file line number Diff line number Diff line change
@@ -1,113 +1,53 @@
import { Gql } from './LogicConnection'
import { IsBoolean, IsInteger, IsString, IsStringArray, ReadStored, RemoveStored, WriteStored } from './Storage'

const filterStorageKey = 'GameStart:filtersSearchpage'
const sortStorageKey = 'GameStart:sortOptionSearchpage'
const queryStorageKey = 'GameStart:querySearchpage'
const pageStorageKey = 'GameStart:pageSearchpage'
const menuStorageKey = 'GameStart:filterMenuOpenSearchpage'

export async function FetchGenres(): Promise<string[]> {
const data = await Gql<{ genres: string[] }>(`query { genres }`, {})
return data.genres
}

export function GetSavedFiltersSearchpage(): string[] {
try {
const parsed = JSON.parse(sessionStorage.getItem('GameStart:filtersSearchpage') ?? '[]')
return Array.isArray(parsed) ? parsed : []
} catch {
return []
}
return ReadStored(filterStorageKey, [], IsStringArray)
}

export function SaveFiltersSearchpage(filters: string[]) {
try {
sessionStorage.setItem('GameStart:filtersSearchpage', JSON.stringify(filters))
} catch (error: unknown) {
const message = error instanceof Error ? error.message : String(error)
console.log(`Searchpage: Could not save filters to session storage: ${message}`)
}
WriteStored(filterStorageKey, filters)
}

export function GetQuerySearchpage(): string {
try {
const parsed = JSON.parse(sessionStorage.getItem('GameStart:querySearchpage') ?? '""')
return typeof parsed === 'string' ? parsed : ''
} catch {
return ''
}
return ReadStored(queryStorageKey, '', IsString)
}

export function SaveQuerySearchpage(query: string) {
try {
sessionStorage.setItem('GameStart:querySearchpage', JSON.stringify(query))
} catch (error: unknown) {
const message = error instanceof Error ? error.message : String(error)
console.log(`Searchpage: Could not save search query to session storage: ${message}`)
}
WriteStored(queryStorageKey, query)
}

export function SaveSortOptionSearchpage(query: string) {
try {
sessionStorage.setItem('GameStart:sortOptionSearchpage', JSON.stringify(query))
} catch (error: unknown) {
const message = error instanceof Error ? error.message : String(error)
console.log(`Searchpage: Could not save sorting option to session storage: ${message}`)
}
WriteStored(sortStorageKey, query)
}

export function GetSortOptionSearchpage(): string {
try {
const parsed = JSON.parse(sessionStorage.getItem('GameStart:sortOptionSearchpage') ?? '""')
return typeof parsed === 'string' ? parsed : ''
} catch {
return ''
}
return ReadStored(sortStorageKey, '', IsString)
}

export function SavePageSearchpage(pageNumber: number) {
try {
sessionStorage.setItem('GameStart:pageSearchpage', JSON.stringify(pageNumber))
} catch (error: unknown) {
const message = error instanceof Error ? error.message : String(error)
console.log(`Searchpage: Could not save page to session storage: ${message}`)
}
WriteStored(pageStorageKey, pageNumber)
}

export function GetPageSearchpage(): number {
try {
const parsed = JSON.parse(sessionStorage.getItem('GameStart:pageSearchpage') ?? '1')
return Number.isInteger(parsed) && parsed >= 1 ? parsed : 1
} catch {
return 1
}
return ReadStored(pageStorageKey, 1, IsInteger)
}

export function SaveFilterMenuOpenSearchpage(isOpen: boolean) {
try {
sessionStorage.setItem('GameStart:filterMenuOpenSearchpage', JSON.stringify(isOpen))
} catch (error: unknown) {
const message = error instanceof Error ? error.message : String(error)
console.log(`Searchpage: Could not save filter menu state to session storage: ${message}`)
}
WriteStored(menuStorageKey, isOpen)
}

export function GetFilterMenuOpenSearchpage(): boolean {
try {
return JSON.parse(sessionStorage.getItem('GameStart:filterMenuOpenSearchpage') ?? 'false') === true
} catch {
return false
}
}

export function ClearFilterAndSort() {
try {
sessionStorage.removeItem('GameStart:sortOptionSearchpage')
sessionStorage.removeItem('GameStart:filtersSearchpage')
sessionStorage.removeItem('GameStart:filterMenuOpenSearchpage')
} catch (error) {
console.log(`Could not clear filters and sorting from storage`)
}
}

export function ClearSearch() {
try {
sessionStorage.removeItem('GameStart:pageSearchpage')
} catch (error) {
console.log(`Could not clear search from storage`)
}
return ReadStored(menuStorageKey, false, IsBoolean)
}
65 changes: 65 additions & 0 deletions Frontend/src/FrontendLogic/Storage.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,65 @@
import type { User } from "../types/User"

type StorageKind = 'session' | 'local'

export const IsString = (value: unknown): value is string => typeof value === 'string'
export const IsBoolean = (value: unknown): value is boolean => typeof value === 'boolean'
// export const IsNumber = (value: unknown): value is number =>
// typeof value === 'number' && Number.isFinite(value) && value > 0
export const IsInteger = (value: unknown): value is number => typeof value === 'number' && Number.isInteger(value) && value > 0
export const IsStringArray = (value: unknown): value is string[] => Array.isArray(value)
export const IsNull = (value: unknown): value is null => value === 'null'
export const IsUser = (value: unknown): value is User => {
if (typeof value !== 'object' || value === null) return false
const user = value as Partial<Record<keyof User, unknown>>
return (
typeof user.id === 'number' &&
typeof user.email === 'string' &&
typeof user.username === 'string' &&
typeof user.token === 'string'
)
}
export const OrNull =
<T>(isValid: (value: unknown) => value is T) =>
(value: unknown): value is T | null =>
value === null || isValid(value)

function GetStorage(kind: StorageKind): Storage {
return kind === 'local' ? localStorage : sessionStorage
}

// Reads a value and returns the fallback if it is missing, corrupt or fails the check.
export function ReadStored<T>(
key: string,
fallback: T,
isValid: (value: unknown) => value is T,
kind: StorageKind = 'session',
onError?: (error: unknown) => void
): T {
try {
const raw = GetStorage(kind).getItem(key)
if (raw === null) return fallback
const parsed: unknown = JSON.parse(raw)
return isValid(parsed) ? parsed : fallback
} catch (error) {
onError?.(error)
return fallback
}
}

export function WriteStored(key: string, value: unknown, kind: StorageKind = 'session') {
try {
GetStorage(kind).setItem(key, JSON.stringify(value))
} catch (error: unknown) {
const message = error instanceof Error ? error.message : String(error)
console.log(`Could not save "${key}" to ${kind} storage: ${message}`)
}
}

export function RemoveStored(key: string, kind: StorageKind = 'session') {
try {
GetStorage(kind).removeItem(key)
} catch {
console.log(`Could not remove "${key}" from ${kind} storage`)
}
}
Loading