Simply read the npm cache

Author: jablko

packages/publisher/src/generate-packages.ts

@@ -1,5 +1,4 @@
 import { makeTypesVersionsForPackageJson } from "@definitelytyped/header-parser";
-import assert = require("assert");
 import { emptyDir, mkdir, mkdirp, readFileSync } from "fs-extra";
 import path = require("path");
 import yargs = require("yargs");
@@ -17,9 +16,8 @@ import {
   writeLog,
   writeFile,
   Logger,
+  NpmInfoRaw,
   writeTgz,
-  withNpmCache,
-  CachedNpmInfoClient,
 } from "@definitelytyped/utils";
 import {
   getDefinitelyTyped,
@@ -69,16 +67,11 @@ export default async function generatePackages(
     log(` * ${pkg.desc}`);
   }
   log("## Generating deprecated packages");
-  await withNpmCache(
-    undefined,
-    async (offline) => {
-      for (const pkg of changedPackages.changedNotNeededPackages) {
-        log(` * ${pkg.libraryName}`);
-        await generateNotNeededPackage(pkg, offline, log);
-      }
-    },
-    cacheDirPath
-  );
+  const offline: Record<string, NpmInfoRaw> = await import(`${cacheDirPath}/npmInfo.json`);
+  for (const pkg of changedPackages.changedNotNeededPackages) {
+    log(` * ${pkg.libraryName}`);
+    await generateNotNeededPackage(pkg, offline, log);
+  }
   await writeLog("package-generator.md", logResult());
 }
 async function generateTypingPackage(
@@ -101,12 +94,11 @@ async function generateTypingPackage(
 
 async function generateNotNeededPackage(
   pkg: NotNeededPackage,
-  offline: Omit<CachedNpmInfoClient, "fetchAndCacheNpmInfo">,
+  offline: Record<string, NpmInfoRaw>,
   log: Logger
 ): Promise<void> {
   pkg = skipBadPublishes(pkg, offline, log);
-  const info = offline.getNpmInfoFromCache(pkg.libraryName);
-  assert(info);
+  const info = offline[pkg.libraryName];
   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!`;
   await writeCommonOutputs(pkg, createNotNeededPackageJSON(pkg), readme);

packages/publisher/src/lib/npm.ts

@@ -1,19 +1,15 @@
 import { NotNeededPackage } from "@definitelytyped/definitions-parser";
-import { Logger, assertDefined, CachedNpmInfoClient, max } from "@definitelytyped/utils";
+import { Logger, NpmInfoRaw, assertDefined, max } from "@definitelytyped/utils";
 import * as semver from "semver";
 
 /**
  * When we fail to publish a deprecated package, it leaves behind an entry in the time property.
  * 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,
-  offline: Omit<CachedNpmInfoClient, "fetchAndCacheNpmInfo">,
-  log: Logger
-) {
+export function skipBadPublishes(pkg: NotNeededPackage, offline: Record<string, NpmInfoRaw>, log: Logger) {
   // because this is called right after isAlreadyDeprecated, we can rely on the cache being up-to-date
-  const info = assertDefined(offline.getNpmInfoFromCache(pkg.fullNpmName));
+  const info = assertDefined(offline[pkg.fullNpmName]);
   const notNeeded = pkg.version;
   const latest = new semver.SemVer(findActualLatest(info.time));
   if (semver.lte(notNeeded, latest)) {
@@ -24,9 +20,9 @@ export function skipBadPublishes(
   return pkg;
 }
 
-function findActualLatest(times: Map<string, string>) {
+function findActualLatest(times: NpmInfoRaw["time"]) {
   const actual = max(
-    [...times].filter(([version]) => version !== "modified" && version !== "created"),
+    Object.entries(times).filter(([version]) => version !== "modified" && version !== "created"),
     ([, a], [, b]) => (new Date(a) as never) - (new Date(b) as never)
   );
   if (!actual) {

packages/publisher/src/publish-packages.ts

@@ -9,9 +9,9 @@ import {
   logUncaughtErrors,
   logger,
   Fetcher,
+  NpmInfoRaw,
   writeLog,
   NpmPublishClient,
-  withNpmCache,
 } from "@definitelytyped/utils";
 import { readChangedPackages, ChangedPackages } from "./lib/versions";
 import { skipBadPublishes } from "./lib/npm";
@@ -142,16 +142,11 @@ export default async function publishPackages(
     }
   }
 
-  await withNpmCache(
-    undefined,
-    async (offline) => {
-      for (const n of changedPackages.changedNotNeededPackages) {
-        const target = skipBadPublishes(n, offline, log);
-        await publishNotNeededPackage(client, target, dry, log);
-      }
-    },
-    cacheDirPath
-  );
+  const offline: Record<string, NpmInfoRaw> = await import(`${cacheDirPath}/npmInfo.json`);
+  for (const n of changedPackages.changedNotNeededPackages) {
+    const target = skipBadPublishes(n, offline, log);
+    await publishNotNeededPackage(client, target, dry, log);
+  }
 
   await writeLog("publishing.md", logResult());
   console.log("Done!");

packages/publisher/src/publish-registry.ts

@@ -24,13 +24,12 @@ import {
   writeJson,
   writeFile,
   Logger,
+  NpmInfoRaw,
   sleep,
   npmInstallFlags,
   readJson,
   UncachedNpmInfoClient,
-  withNpmCache,
   NpmPublishClient,
-  CachedNpmInfoClient,
   isObject,
   max,
 } from "@definitelytyped/utils";
@@ -69,11 +68,8 @@ export default async function publishRegistry(
   assert.strictEqual(npmVersion.minor, 1);
 
   // Don't include not-needed packages in the registry.
-  const registryJsonData = await withNpmCache(
-    undefined,
-    (offline) => generateRegistry(allPackages.allLatestTypings(), offline),
-    cacheDirPath
-  );
+  const offline: Record<string, NpmInfoRaw> = await import(`${cacheDirPath}/npmInfo.json`);
+  const registryJsonData = await generateRegistry(allPackages.allLatestTypings(), offline);
   const registry = JSON.stringify(registryJsonData);
   const newContentHash = computeHash(registry);
   const newVersion = semver.inc(npmVersion, "patch")!;
@@ -251,30 +247,24 @@ interface Registry {
 }
 async function generateRegistry(
   typings: readonly TypingsData[],
-  offline: Omit<CachedNpmInfoClient, "fetchAndCacheNpmInfo">
+  offline: Record<string, NpmInfoRaw>
 ): 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 = offline.getNpmInfoFromCache(typing.fullNpmName);
+    const info = offline[typing.fullNpmName];
     if (!info) {
-      const missings = typings.filter((t) => !offline.getNpmInfoFromCache(t.fullNpmName)).map((t) => t.fullNpmName);
+      const missings = typings.filter((t) => !(t.fullNpmName in offline)).map((t) => t.fullNpmName);
       throw new Error(`${missings.toString()} not found in cached npm info.`);
     }
-    entries[typing.name] = filterTags(info.distTags);
+    entries[typing.name] = filterTags(info["dist-tags"]);
   }
   return { entries };
 
-  function filterTags(tags: Map<string, string>): { readonly [tag: string]: string } {
-    const latestTag = "latest";
-    const latestVersion = tags.get(latestTag);
-    const out: { [tag: string]: string } = {};
-    tags.forEach((value, tag) => {
-      if (tag === latestTag || value !== latestVersion) {
-        out[tag] = value;
-      }
-    });
-    return out;
+  function filterTags(tags: NpmInfoRaw["dist-tags"]): { readonly [tag: string]: string } {
+    return Object.fromEntries(
+      Object.entries(tags).filter(([tag, version]) => tag === "latest" || version !== tags.latest)
+    );
   }
 }
 

packages/utils/src/npm.ts

@@ -50,17 +50,7 @@ export interface CachedNpmInfoClient {
 
 export async function withNpmCache<T>(
   uncachedClient: UncachedNpmInfoClient,
-  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,
+  cb: (client: CachedNpmInfoClient) => Promise<T>,
   cacheDir = defaultCacheDir
 ): Promise<T> {
   const log = loggerWithErrors()[0];
@@ -79,12 +69,9 @@ export async function withNpmCache<T>(
   }
 
   const res = await cb({ getNpmInfoFromCache, fetchAndCacheNpmInfo });
-  // 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));
-  }
+  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. */
@@ -94,7 +81,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);
     }

tsconfig.base.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es2018",
+    "target": "es2019",
     "module": "commonjs",
     "strict": true,
     "esModuleInterop": true,