@commitspark/graphql-api 1.0.0 → 2.0.0-beta.2

package/src/persistence/cache.ts

@@ -3,7 +3,11 @@ import { ApolloContext } from '../client.ts'
 import { createError, ErrorCode } from '../graphql/errors.ts'
 
 type Ref = string
-type EntriesCache = Map<Ref, EntriesRecord>
+type ContentHash = string
+type EntryContent = Omit<Entry, 'id'>
+type EntriesCache = Map<Ref, CommitCacheRecord>
+// entry content shared across all cached commits, so that unchanged entries are neither fetched nor stored twice
+type ContentCache = Map<ContentHash, EntryContent>
 type SchemaCache = Map<Ref, string>
 type InflightEntries = Map<Ref, Promise<EntriesRecord>>
 
@@ -12,6 +16,11 @@ interface EntriesRecord {
   byType: Map<string, Entry[]>
 }
 
+interface CommitCacheRecord {
+  entriesRecord: EntriesRecord
+  contentHashes: ContentHash[]
+}
+
 export interface RepositoryCacheHandler {
   getEntriesRecord: (
     context: ApolloContext,
@@ -25,6 +34,7 @@ const MAX_CACHE_ENTRIES = 50
 // intentionally not async so that the same in-flight promise is returned to all callers
 const getEntriesRecordByRef = (
   entriesCache: EntriesCache,
+  contentCache: ContentCache,
   inflightEntries: InflightEntries,
   cacheSize: number,
   context: ApolloContext,
@@ -36,7 +46,7 @@ const getEntriesRecordByRef = (
     entriesCache.delete(ref)
     entriesCache.set(ref, cacheRecord)
 
-    return Promise.resolve(cacheRecord)
+    return Promise.resolve(cacheRecord.entriesRecord)
   }
 
   const inflightPromise = inflightEntries.get(ref)
@@ -46,6 +56,7 @@ const getEntriesRecordByRef = (
 
   const fetchPromise = fetchAndCacheEntries(
     entriesCache,
+    contentCache,
     cacheSize,
     context,
     ref,
@@ -58,34 +69,72 @@ const getEntriesRecordByRef = (
 
 const fetchAndCacheEntries = async (
   entriesCache: EntriesCache,
+  contentCache: ContentCache,
   cacheSize: number,
   context: ApolloContext,
   ref: string,
 ): Promise<EntriesRecord> => {
-  let allEntries: Entry[]
-  try {
-    allEntries = await context.gitAdapter.getEntries(ref)
-  } catch (err) {
-    if (err instanceof GitAdapterError) {
-      throw createError(err.message, err.code, {})
+  const entryHashes = await callGitAdapter(() =>
+    context.gitAdapter.getEntryHashes(ref),
+  )
+
+  // hold on to known content now, as it may be evicted from the content cache while missing content is fetched
+  const contentByHash = new Map<ContentHash, EntryContent>()
+  const idsToFetchByHash = new Map<ContentHash, string>()
+  for (const { id, hash } of entryHashes) {
+    const content = contentCache.get(hash)
+    if (content !== undefined) {
+      contentByHash.set(hash, content)
+    } else if (!idsToFetchByHash.has(hash)) {
+      // entries with equal hash have equal content, so fetching one of them is sufficient
+      idsToFetchByHash.set(hash, id)
+    }
+  }
+
+  if (idsToFetchByHash.size > 0) {
+    const fetchedEntries = await callGitAdapter(() =>
+      context.gitAdapter.getEntriesByIds(ref, [...idsToFetchByHash.values()]),
+    )
+    const fetchedEntriesById = new Map(
+      fetchedEntries.map((entry) => [entry.id, entry]),
+    )
+    for (const [hash, id] of idsToFetchByHash) {
+      const fetchedEntry = fetchedEntriesById.get(id)
+      if (fetchedEntry === undefined) {
+        throw createError(
+          `Git adapter did not return requested entry "${id}".`,
+          ErrorCode.INTERNAL_ERROR,
+          {},
+        )
+      }
+      contentByHash.set(hash, createEntryContent(fetchedEntry))
     }
-    const message = err instanceof Error ? err.message : String(err)
-    throw createError(message, ErrorCode.INTERNAL_ERROR, {})
   }
 
-  const entriesById = new Map(allEntries.map((entry) => [entry.id, entry]))
+  const entriesById = new Map<string, Entry>()
   const entriesByType = new Map<string, Entry[]>()
-  for (const entry of allEntries) {
+  for (const { id, hash } of entryHashes) {
+    const entry: Entry = {
+      id: id,
+      ...(contentByHash.get(hash) as EntryContent),
+    }
+    entriesById.set(id, entry)
     const existingEntriesOfType = entriesByType.get(entry.metadata.type) || []
     existingEntriesOfType.push(entry)
     entriesByType.set(entry.metadata.type, existingEntriesOfType)
   }
 
-  const newCacheRecord = {
-    byType: entriesByType,
-    byId: entriesById,
+  const newCacheRecord: CommitCacheRecord = {
+    entriesRecord: {
+      byType: entriesByType,
+      byId: entriesById,
+    },
+    contentHashes: [...contentByHash.keys()],
   }
 
+  for (const [hash, content] of contentByHash) {
+    contentCache.set(hash, content)
+  }
   entriesCache.set(ref, newCacheRecord)
 
   if (entriesCache.size > cacheSize) {
@@ -93,10 +142,48 @@ const fetchAndCacheEntries = async (
     const oldestKey = entriesCache.keys().next().value as Ref | undefined
     if (oldestKey !== undefined) {
       entriesCache.delete(oldestKey)
+      removeUnreferencedContent(entriesCache, contentCache)
     }
   }
 
-  return newCacheRecord
+  return newCacheRecord.entriesRecord
+}
+
+const createEntryContent = (entry: Entry): EntryContent => {
+  const content: EntryContent = { metadata: entry.metadata }
+  if (entry.data !== undefined) {
+    content.data = entry.data
+  }
+  return content
+}
+
+const removeUnreferencedContent = (
+  entriesCache: EntriesCache,
+  contentCache: ContentCache,
+): void => {
+  const referencedHashes = new Set<ContentHash>()
+  for (const cacheRecord of entriesCache.values()) {
+    for (const hash of cacheRecord.contentHashes) {
+      referencedHashes.add(hash)
+    }
+  }
+  for (const hash of contentCache.keys()) {
+    if (!referencedHashes.has(hash)) {
+      contentCache.delete(hash)
+    }
+  }
+}
+
+const callGitAdapter = async <T>(operation: () => Promise<T>): Promise<T> => {
+  try {
+    return await operation()
+  } catch (err) {
+    if (err instanceof GitAdapterError) {
+      throw createError(err.message, err.code, {})
+    }
+    const message = err instanceof Error ? err.message : String(err)
+    throw createError(message, ErrorCode.INTERNAL_ERROR, {})
+  }
 }
 
 const getSchemaStringByRef = async (
@@ -114,16 +201,9 @@ const getSchemaStringByRef = async (
     return schemaCacheRecord
   }
 
-  let schemaString
-  try {
-    schemaString = await context.gitAdapter.getSchema(ref)
-  } catch (err) {
-    if (err instanceof GitAdapterError) {
-      throw createError(err.message, err.code, {})
-    }
-    const message = err instanceof Error ? err.message : String(err)
-    throw createError(message, ErrorCode.INTERNAL_ERROR, {})
-  }
+  const schemaString = await callGitAdapter(() =>
+    context.gitAdapter.getSchema(ref),
+  )
 
   schemaCache.set(ref, schemaString)
 
@@ -141,7 +221,8 @@ const getSchemaStringByRef = async (
 export const createCacheHandler = (
   cacheSize: number = MAX_CACHE_ENTRIES,
 ): RepositoryCacheHandler => {
-  const entriesCache: EntriesCache = new Map<Ref, EntriesRecord>()
+  const entriesCache: EntriesCache = new Map<Ref, CommitCacheRecord>()
+  const contentCache: ContentCache = new Map<ContentHash, EntryContent>()
   const schemaCache: SchemaCache = new Map<Ref, string>()
   const inflightEntries: InflightEntries = new Map<
     Ref,
@@ -149,7 +230,13 @@ export const createCacheHandler = (
   >()
   return {
     getEntriesRecord: (...args) =>
-      getEntriesRecordByRef(entriesCache, inflightEntries, cacheSize, ...args),
+      getEntriesRecordByRef(
+        entriesCache,
+        contentCache,
+        inflightEntries,
+        cacheSize,
+        ...args,
+      ),
     getSchema: (...args) =>
       getSchemaStringByRef(schemaCache, cacheSize, ...args),
   }