Use cached npm info

Author: jablko

packages/publisher/src/generate-packages.ts

@@ -19,7 +19,6 @@ import {
   Logger,
   writeTgz,
   withNpmCache,
-  UncachedNpmInfoClient,
   CachedNpmInfoClient,
 } from "@definitelytyped/utils";
 import {
@@ -71,11 +70,11 @@ export default async function generatePackages(
   }
   log("## Generating deprecated packages");
   await withNpmCache(
-    new UncachedNpmInfoClient(),
-    async (client) => {
+    undefined,
+    async (offline) => {
       for (const pkg of changedPackages.changedNotNeededPackages) {
         log(` * ${pkg.libraryName}`);
-        await generateNotNeededPackage(pkg, client, log);
+        await generateNotNeededPackage(pkg, offline, log);
       }
     },
     cacheDirPath
@@ -102,11 +101,11 @@ async function generateTypingPackage(
 
 async function generateNotNeededPackage(
   pkg: NotNeededPackage,
-  client: CachedNpmInfoClient,
+  offline: Omit<CachedNpmInfoClient, "fetchAndCacheNpmInfo">,
   log: Logger
 ): Promise<void> {
-  pkg = skipBadPublishes(pkg, client, log);
-  const info = await client.fetchAndCacheNpmInfo(pkg.libraryName);
+  pkg = skipBadPublishes(pkg, offline, log);
+  const info = offline.getNpmInfoFromCache(pkg.libraryName);
   assert(info);
   const readme = `This is a stub types definition for ${getFullNpmName(pkg.name)} (${info.homepage}).\n
 ${pkg.libraryName} provides its own type definitions, so you don't need ${getFullNpmName(pkg.name)} installed!`;

packages/publisher/src/lib/npm.ts

@@ -7,9 +7,13 @@ import * as semver from "semver";
  * So the keys of 'time' give the actual 'latest'.
  * If that's not equal to the expected latest, try again by bumping the patch version of the last attempt by 1.
  */
-export function skipBadPublishes(pkg: NotNeededPackage, client: CachedNpmInfoClient, log: Logger) {
+export function skipBadPublishes(
+  pkg: NotNeededPackage,
+  offline: Omit<CachedNpmInfoClient, "fetchAndCacheNpmInfo">,
+  log: Logger
+) {
   // because this is called right after isAlreadyDeprecated, we can rely on the cache being up-to-date
-  const info = assertDefined(client.getNpmInfoFromCache(pkg.fullNpmName));
+  const info = assertDefined(offline.getNpmInfoFromCache(pkg.fullNpmName));
   const notNeeded = pkg.version;
   const latest = new semver.SemVer(findActualLatest(info.time));
   if (semver.lte(notNeeded, latest)) {

packages/publisher/src/publish-packages.ts

@@ -12,7 +12,6 @@ import {
   writeLog,
   NpmPublishClient,
   withNpmCache,
-  UncachedNpmInfoClient,
 } from "@definitelytyped/utils";
 import { readChangedPackages, ChangedPackages } from "./lib/versions";
 import { skipBadPublishes } from "./lib/npm";
@@ -144,10 +143,10 @@ export default async function publishPackages(
   }
 
   await withNpmCache(
-    new UncachedNpmInfoClient(),
-    async (infoClient) => {
+    undefined,
+    async (offline) => {
       for (const n of changedPackages.changedNotNeededPackages) {
-        const target = skipBadPublishes(n, infoClient, log);
+        const target = skipBadPublishes(n, offline, log);
         await publishNotNeededPackage(client, target, dry, log);
       }
     },

packages/publisher/src/publish-registry.ts

@@ -70,8 +70,8 @@ export default async function publishRegistry(
 
   // Don't include not-needed packages in the registry.
   const registryJsonData = await withNpmCache(
-    client,
-    (cachedClient) => generateRegistry(allPackages.allLatestTypings(), cachedClient),
+    undefined,
+    (offline) => generateRegistry(allPackages.allLatestTypings(), offline),
     cacheDirPath
   );
   const registry = JSON.stringify(registryJsonData);
@@ -249,13 +249,16 @@ interface Registry {
     };
   };
 }
-async function generateRegistry(typings: readonly TypingsData[], client: CachedNpmInfoClient): Promise<Registry> {
+async function generateRegistry(
+  typings: readonly TypingsData[],
+  offline: Omit<CachedNpmInfoClient, "fetchAndCacheNpmInfo">
+): Promise<Registry> {
   const entries: { [packageName: string]: { [distTags: string]: string } } = {};
   for (const typing of typings) {
     // Unconditionally use cached info, this should have been set in calculate-versions so should be recent enough.
-    const info = client.getNpmInfoFromCache(typing.fullNpmName);
+    const info = offline.getNpmInfoFromCache(typing.fullNpmName);
     if (!info) {
-      const missings = typings.filter((t) => !client.getNpmInfoFromCache(t.fullNpmName)).map((t) => t.fullNpmName);
+      const missings = typings.filter((t) => !offline.getNpmInfoFromCache(t.fullNpmName)).map((t) => t.fullNpmName);
       throw new Error(`${missings.toString()} not found in cached npm info.`);
     }
     entries[typing.name] = filterTags(info.distTags);

packages/utils/src/npm.ts

@@ -50,7 +50,17 @@ export interface CachedNpmInfoClient {
 
 export async function withNpmCache<T>(
   uncachedClient: UncachedNpmInfoClient,
-  cb: (client: CachedNpmInfoClient) => Promise<T>,
+  cb: (client: CachedNpmInfoClient) => T,
+  cacheDir?: string
+): Promise<T>;
+export async function withNpmCache<T>(
+  uncachedClient: undefined,
+  cb: (offline: Omit<CachedNpmInfoClient, "fetchAndCacheNpmInfo">) => T,
+  cacheDir?: string
+): Promise<T>;
+export async function withNpmCache<T>(
+  uncachedClient: UncachedNpmInfoClient | undefined,
+  cb: (client: CachedNpmInfoClient) => T,
   cacheDir = defaultCacheDir
 ): Promise<T> {
   const log = loggerWithErrors()[0];
@@ -69,9 +79,12 @@ export async function withNpmCache<T>(
   }
 
   const res = await cb({ getNpmInfoFromCache, fetchAndCacheNpmInfo });
-  log.info("Writing npm cache.");
-  await ensureFile(cacheFile);
-  await writeJson(cacheFile, mapToRecord(unroll, jsonFromNpmInfo));
+  // Don't bother writing if there's no way we could have gone to the origin.
+  if (uncachedClient) {
+    log.info("Writing npm cache.");
+    await ensureFile(cacheFile);
+    await writeJson(cacheFile, mapToRecord(unroll, jsonFromNpmInfo));
+  }
   return res;
 
   /** May return old info -- caller should check that this looks up-to-date. */
@@ -81,7 +94,7 @@ export async function withNpmCache<T>(
 
   /** Call this when the result of getNpmInfoFromCache looks potentially out-of-date. */
   async function fetchAndCacheNpmInfo(packageName: string): Promise<NpmInfo | undefined> {
-    const info = await uncachedClient.fetchNpmInfo(packageName);
+    const info = await uncachedClient!.fetchNpmInfo(packageName);
     if (info) {
       unroll.set(packageName, info);
     }