This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/gitgram/web/utils/apiCache.ts
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

120 lines
2.8 KiB
TypeScript

type CacheEntry<T> = {
data: T
timestamp: number
expiresAt: number
}
class APICache {
private cache: Map<string, CacheEntry<any>> = new Map()
private defaultTTL = 5 * 60 * 1000 // 5 minutes default
/**
* Get cached data if valid
*/
get<T>(key: string): T | null {
const entry = this.cache.get(key)
if (!entry) return null
if (Date.now() > entry.expiresAt) {
this.cache.delete(key)
return null
}
return entry.data as T
}
/**
* Set cached data with optional TTL
*/
set<T>(key: string, data: T, ttlMs?: number): void {
const ttl = ttlMs ?? this.defaultTTL
this.cache.set(key, {
data,
timestamp: Date.now(),
expiresAt: Date.now() + ttl,
})
}
/**
* Invalidate a specific cache key
*/
invalidate(key: string): void {
this.cache.delete(key)
}
/**
* Invalidate all cache keys matching a pattern
*/
invalidatePattern(pattern: string): void {
const regex = new RegExp(pattern)
for (const key of this.cache.keys()) {
if (regex.test(key)) {
this.cache.delete(key)
}
}
}
/**
* Clear entire cache
*/
clear(): void {
this.cache.clear()
}
/**
* Get or fetch data with caching
*/
async getOrFetch<T>(
key: string,
fetcher: () => Promise<T>,
ttlMs?: number
): Promise<T> {
const cached = this.get<T>(key)
if (cached !== null) {
return cached
}
const data = await fetcher()
this.set(key, data, ttlMs)
return data
}
/**
* Prefetch and cache data in background
*/
prefetch<T>(key: string, fetcher: () => Promise<T>, ttlMs?: number): void {
fetcher()
.then((data) => this.set(key, data, ttlMs))
.catch(() => {
// Silent fail for prefetch
})
}
}
// Singleton instance
export const apiCache = new APICache()
// Cache key generators
export const cacheKeys = {
user: (userId: string) => `user:${userId}`,
userProfile: (username: string) => `profile:${username}`,
post: (postId: string) => `post:${postId}`,
posts: (page: number, userId?: string) => `posts:${page}:${userId || 'feed'}`,
comments: (postId: string, page: number) => `comments:${postId}:${page}`,
followers: (userId: string, page: number) => `followers:${userId}:${page}`,
following: (userId: string, page: number) => `following:${userId}:${page}`,
notifications: (page: number) => `notifications:${page}`,
trending: (timeframe: string) => `trending:${timeframe}`,
insights: (days: number) => `insights:${days}`,
stories: () => 'stories:feed',
reels: (page: number) => `reels:${page}`,
}
// TTL constants (in milliseconds)
export const cacheTTL = {
short: 30 * 1000, // 30 seconds
medium: 5 * 60 * 1000, // 5 minutes
long: 15 * 60 * 1000, // 15 minutes
veryLong: 60 * 60 * 1000, // 1 hour
}