fix: improve memoize type safety for nullable data

Author: 9romise

src/extractors/package-json.ts

@@ -14,7 +14,7 @@ const DEPENDENCY_SECTIONS = [
 ]
 
 export class PackageJsonExtractor implements Extractor<Node> {
-  parse = createCachedParse(parseTree)
+  parse = createCachedParse((text) => parseTree(text) ?? null)
 
   getNodeRange(doc: TextDocument, node: Node) {
     const start = doc.positionAt(node.offset + 1)

src/providers/completion-item/version.ts

@@ -29,6 +29,8 @@ export class VersionCompletionItemProvider<T extends Extractor> implements Compl
     } = info
 
     const pkg = await getPackageInfo(name)
+    if (!pkg)
+      return
 
     const prefix = extractVersionPrefix(version)
 

src/providers/diagnostics/index.ts

@@ -48,6 +48,8 @@ export function registerDiagnosticCollection(mapping: Record<string, Extractor |
       dependencies.map(async (dep) => {
         try {
           const pkg = await getPackageInfo(dep.name)
+          if (!pkg)
+            return
 
           for (const rule of enabledRules.value) {
             const diagnostic = await rule(dep, pkg)

src/providers/diagnostics/rules/vulnerability.ts

@@ -18,8 +18,11 @@ export const checkVulnerability: DiagnosticRule = async (dep, pkg) => {
   if (!versionInfo)
     return
 
-  const { totalCounts } = await getVulnerability({ name: dep.name, version: versionInfo.version })
+  const result = await getVulnerability({ name: dep.name, version: exactVersion })
+  if (!result)
+    return
 
+  const { totalCounts } = result
   const message: string[] = []
   let severity: DiagnosticSeverity | null = null
 

src/providers/hover/npmx.ts

@@ -27,6 +27,9 @@ export class NpmxHoverProvider<T extends Extractor> implements HoverProvider {
     md.isTrusted = true
 
     const pkg = await getPackageInfo(name)
+    if (!pkg)
+      return
+
     const currentVersion = pkg.versions[coercedVersion]
     if (currentVersion) {
       if (currentVersion.hasProvenance)

src/utils/memoize.ts

@@ -13,14 +13,16 @@ interface MemoizeEntry<V> {
   expiresAt?: number
 }
 
-export function memoize<P, V>(fn: (params: P) => V, options: MemoizeOptions<P> = {}): (params: P) => V {
+type MemoizeReturn<R> = R extends Promise<infer V> ? Promise<V | undefined> : R | undefined
+
+export function memoize<P, V>(fn: (params: P) => V, options: MemoizeOptions<P> = {}): (params: P) => MemoizeReturn<V> {
   const {
     getKey = String,
     ttl = CACHE_TTL_ONE_DAY,
   } = options
 
   const cache = new Map<MemoizeKey, MemoizeEntry<V>>()
-  const pending = new Map<MemoizeKey, V>()
+  const pending = new Map<MemoizeKey, Promise<any>>()
 
   function get(key: MemoizeKey): Awaited<V> | undefined {
     const entry = cache.get(key)
@@ -40,7 +42,7 @@ export function memoize<P, V>(fn: (params: P) => V, options: MemoizeOptions<P> =
     })
   }
 
-  return function cachedFn(params: P): V {
+  return function cachedFn(params: P) {
     const key = getKey(params)
 
     const hit = get(key)
@@ -62,10 +64,10 @@ export function memoize<P, V>(fn: (params: P) => V, options: MemoizeOptions<P> =
         .catch(() => cache.get(key)?.value)
         .finally(() => {
           pending.delete(key)
-        }) as V
+        }) as any
       pending.set(key, promise)
       return promise
-    } else {
+    } else if (result !== undefined) {
       set(key, result as Awaited<V>)
       return result
     }

src/utils/parse.ts

@@ -1,4 +1,4 @@
-import type { Extractor, ValidNode } from '#types/extractor'
+import type { ValidNode } from '#types/extractor'
 import type { TextDocument } from 'vscode'
 import { createHash } from 'node:crypto'
 import { memoize } from './memoize'
@@ -8,8 +8,8 @@ function computeHash(text: string) {
 }
 
 export function createCachedParse<T extends ValidNode>(
-  parse: (text: string) => ReturnType<Extractor<T>['parse']>,
-): Extractor<T>['parse'] {
+  parse: (text: string) => T | null,
+) {
   return memoize(
     (doc: TextDocument) => parse(doc.getText()),
     { getKey: (doc) => `${doc.uri}:${computeHash(doc.getText())}` },