Move skipBadPublishes() -> calculate-versions

Author: jablko

packages/publisher/src/calculate-versions.ts

@@ -11,8 +11,10 @@ import {
   UncachedNpmInfoClient,
   withNpmCache,
   CachedNpmInfoClient,
+  max,
 } from "@definitelytyped/utils";
 import { fetchTypesPackageVersionInfo } from "@definitelytyped/retag";
+import * as semver from "semver";
 import { cacheDirPath } from "./lib/settings";
 
 if (!module.parent) {
@@ -49,7 +51,7 @@ async function computeAndSaveChangedPackages(
     changedTypings: cp.changedTypings.map(
       ({ pkg: { id }, version, latestVersion }): ChangedTypingJson => ({ id, version, latestVersion })
     ),
-    changedNotNeededPackages: cp.changedNotNeededPackages.map((p) => p.name),
+    changedNotNeededPackages: cp.changedNotNeededPackages.map(({ pkg: { name }, version }) => ({ name, version })),
   };
   await writeDataFile(versionsFilename, json);
   return cp;
@@ -80,32 +82,54 @@ async function computeChangedPackages(
   });
   log.info("# Computing deprecated packages...");
   const changedNotNeededPackages = await mapDefinedAsync(allPackages.allNotNeeded(), async (pkg) => {
-    if (!(await isAlreadyDeprecated(pkg, client, log))) {
+    const version = await fetchIncipientStubVersion(pkg, client, log);
+    if (version) {
       assertDefined(
         await client.fetchAndCacheNpmInfo(pkg.libraryName),
         `To deprecate '@types/${pkg.name}', '${pkg.libraryName}' must exist on npm.`
       );
       log.info(`To be deprecated: ${pkg.name}`);
-      return pkg;
+      return { pkg, version };
     }
     return undefined;
   });
   return { changedTypings, changedNotNeededPackages };
 }
 
-async function isAlreadyDeprecated(
+/**
+ * Return the version of the stub @types/package we are about to publish
+ * and deprecate, if that @typees/package is not already deprecated.
+ */
+async function fetchIncipientStubVersion(
   pkg: NotNeededPackage,
   client: CachedNpmInfoClient,
   log: LoggerWithErrors
-): Promise<boolean> {
-  const cachedInfo = client.getNpmInfoFromCache(pkg.fullEscapedNpmName);
-  let latestVersion = cachedInfo && assertDefined(cachedInfo.distTags.get("latest"));
-  let latestVersionInfo = cachedInfo && latestVersion && assertDefined(cachedInfo.versions.get(latestVersion));
+): Promise<string | false> {
+  let info = client.getNpmInfoFromCache(pkg.fullEscapedNpmName);
+  let latestVersion = info && assertDefined(info.distTags.get("latest"));
+  let latestVersionInfo = latestVersion && assertDefined(info!.versions.get(latestVersion));
   if (!latestVersionInfo || !latestVersionInfo.deprecated) {
     log.info(`Version info not cached for deprecated package ${pkg.desc}`);
-    const info = assertDefined(await client.fetchAndCacheNpmInfo(pkg.fullEscapedNpmName));
+    info = assertDefined(await client.fetchAndCacheNpmInfo(pkg.fullEscapedNpmName));
     latestVersion = assertDefined(info.distTags.get("latest"));
     latestVersionInfo = assertDefined(info.versions.get(latestVersion));
   }
-  return !!latestVersionInfo.deprecated;
+  // 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.
+  return (
+    !latestVersionInfo.deprecated &&
+    String(max([pkg.version, semver.inc(findActualLatest(info!.time), "patch")!], semver.compare))
+  );
+}
+
+function findActualLatest(times: Map<string, string>) {
+  const actual = max(
+    [...times].filter(([version]) => version !== "modified" && version !== "created"),
+    ([, a], [, b]) => (new Date(a) as never) - (new Date(b) as never)
+  );
+  if (!actual) {
+    throw new Error("failed to find actual latest");
+  }
+  return actual[0];
 }

packages/publisher/src/generate-packages.ts

@@ -16,7 +16,6 @@ import {
   logger,
   writeLog,
   writeFile,
-  Logger,
   writeTgz,
   withNpmCache,
   UncachedNpmInfoClient,
@@ -36,7 +35,6 @@ import {
 } from "@definitelytyped/definitions-parser";
 import { readChangedPackages, ChangedPackages } from "./lib/versions";
 import { outputDirectory } from "./util/util";
-import { skipBadPublishes } from "./lib/npm";
 
 const mitLicense = readFileSync(joinPaths(__dirname, "..", "LICENSE"), "utf-8");
 
@@ -73,9 +71,9 @@ export default async function generatePackages(
   await withNpmCache(
     new UncachedNpmInfoClient(),
     async (client) => {
-      for (const pkg of changedPackages.changedNotNeededPackages) {
+      for (const { pkg, version } of changedPackages.changedNotNeededPackages) {
         log(` * ${pkg.libraryName}`);
-        await generateNotNeededPackage(pkg, client, log);
+        await generateNotNeededPackage(pkg, version, client);
       }
     },
     cacheDirPath
@@ -102,15 +100,14 @@ async function generateTypingPackage(
 
 async function generateNotNeededPackage(
   pkg: NotNeededPackage,
-  client: CachedNpmInfoClient,
-  log: Logger
+  version: string,
+  client: CachedNpmInfoClient
 ): Promise<void> {
-  pkg = skipBadPublishes(pkg, client, log);
   const info = await client.fetchAndCacheNpmInfo(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!`;
-  await writeCommonOutputs(pkg, createNotNeededPackageJSON(pkg), readme);
+  await writeCommonOutputs(pkg, createNotNeededPackageJSON(pkg, version), readme);
 }
 
 async function writeCommonOutputs(pkg: AnyPackage, packageJson: string, readme: string): Promise<void> {
@@ -210,10 +207,13 @@ function dependencySemver(dependency: DependencyVersion): string {
   return dependency === "*" ? dependency : "^" + formatTypingVersion(dependency);
 }
 
-export function createNotNeededPackageJSON({ libraryName, license, fullNpmName, version }: NotNeededPackage): string {
+export function createNotNeededPackageJSON(
+  { libraryName, license, fullNpmName }: NotNeededPackage,
+  version: string
+): string {
   const out = {
     name: fullNpmName,
-    version: String(version),
+    version,
     typings: null, // tslint:disable-line no-null-keyword
     description: `Stub TypeScript definitions entry for ${libraryName}, which provides its own types definitions`,
     main: "",

packages/publisher/src/lib/npm.ts

@@ -28,13 +28,14 @@ export async function publishTypingsPackage(
 export async function publishNotNeededPackage(
   client: NpmPublishClient,
   pkg: NotNeededPackage,
+  version: string,
   dry: boolean,
   log: Logger
 ): Promise<void> {
   log(`Deprecating ${pkg.name}`);
   await common(client, pkg, log, dry);
   // Don't use a newline in the deprecation message because it will be displayed as "\n" and not as a newline.
-  await deprecateNotNeededPackage(client, pkg, dry, log);
+  await deprecateNotNeededPackage(client, pkg, version, dry, log);
 }
 
 async function common(client: NpmPublishClient, pkg: AnyPackage, log: Logger, dry: boolean): Promise<void> {
@@ -46,14 +47,15 @@ async function common(client: NpmPublishClient, pkg: AnyPackage, log: Logger, dr
 export async function deprecateNotNeededPackage(
   client: NpmPublishClient,
   pkg: NotNeededPackage,
+  version: string,
   dry = false,
   log: Logger
 ): Promise<void> {
   const name = pkg.fullNpmName;
   if (dry) {
-    log("(dry) Skip deprecate not needed package " + name + " at " + pkg.version);
+    log("(dry) Skip deprecate not needed package " + name + " at " + version);
   } else {
-    log(`Deprecating ${name} at ${pkg.version} with message: ${pkg.deprecatedMessage()}.`);
-    await client.deprecate(name, String(pkg.version), pkg.deprecatedMessage());
+    log(`Deprecating ${name} at ${version} with message: ${pkg.deprecatedMessage()}.`);
+    await client.deprecate(name, version, pkg.deprecatedMessage());
   }
 }

packages/publisher/src/lib/package-publisher.ts

@@ -19,7 +19,7 @@ export interface ChangedTyping {
 
 export interface ChangedPackagesJson {
   readonly changedTypings: readonly ChangedTypingJson[];
-  readonly changedNotNeededPackages: readonly string[];
+  readonly changedNotNeededPackages: readonly { readonly name: string; readonly version: string }[];
 }
 
 export interface ChangedTypingJson {
@@ -30,7 +30,7 @@ export interface ChangedTypingJson {
 
 export interface ChangedPackages {
   readonly changedTypings: readonly ChangedTyping[];
-  readonly changedNotNeededPackages: readonly NotNeededPackage[];
+  readonly changedNotNeededPackages: readonly { readonly pkg: NotNeededPackage; readonly version: string }[];
 }
 
 export async function readChangedPackages(allPackages: AllPackages): Promise<ChangedPackages> {
@@ -43,8 +43,9 @@ export async function readChangedPackages(allPackages: AllPackages): Promise<Cha
         latestVersion,
       })
     ),
-    changedNotNeededPackages: json.changedNotNeededPackages.map((id) =>
-      assertDefined(allPackages.getNotNeededPackage(id))
-    ),
+    changedNotNeededPackages: json.changedNotNeededPackages.map(({ name, version }) => ({
+      pkg: assertDefined(allPackages.getNotNeededPackage(name)),
+      version,
+    })),
   };
 }

packages/publisher/src/lib/versions.ts

@@ -11,13 +11,9 @@ import {
   Fetcher,
   writeLog,
   NpmPublishClient,
-  withNpmCache,
-  UncachedNpmInfoClient,
 } from "@definitelytyped/utils";
 import { readChangedPackages, ChangedPackages } from "./lib/versions";
-import { skipBadPublishes } from "./lib/npm";
 import { getSecret, Secret } from "./lib/secrets";
-import { cacheDirPath } from "./lib/settings";
 
 if (!module.parent) {
   const dry = !!yargs.argv.dry;
@@ -27,11 +23,12 @@ if (!module.parent) {
     if (deprecateName !== undefined) {
       // A '--deprecate' command is available in case types-publisher got stuck *while* trying to deprecate a package.
       // Normally this should not be needed.
-
+      const pkg = AllPackages.readSingleNotNeeded(deprecateName, dt);
       const log = logger()[0];
       await deprecateNotNeededPackage(
         await NpmPublishClient.create(await getSecret(Secret.NPM_TOKEN), undefined),
-        AllPackages.readSingleNotNeeded(deprecateName, dt),
+        pkg,
+        String(pkg.version),
         /*dry*/ false,
         log
       );
@@ -143,16 +140,9 @@ export default async function publishPackages(
     }
   }
 
-  await withNpmCache(
-    new UncachedNpmInfoClient(),
-    async (infoClient) => {
-      for (const n of changedPackages.changedNotNeededPackages) {
-        const target = skipBadPublishes(n, infoClient, log);
-        await publishNotNeededPackage(client, target, dry, log);
-      }
-    },
-    cacheDirPath
-  );
+  for (const { pkg, version } of changedPackages.changedNotNeededPackages) {
+    await publishNotNeededPackage(client, pkg, version, dry, log);
+  }
 
   await writeLog("publishing.md", logResult());
   console.log("Done!");

packages/publisher/src/publish-packages.ts

@@ -137,7 +137,7 @@ testo({
 }`);
   },
   basicNotNeededPackageJson() {
-    const s = createNotNeededPackageJSON(createUnneededPackage());
+    const s = createNotNeededPackageJSON(createUnneededPackage(), "1.1.1");
     expect(s).toEqual(`{
     "name": "@types/absalom",
     "version": "1.1.1",
@@ -154,7 +154,7 @@ testo({
   },
   scopedNotNeededPackageJson() {
     const scopedUnneeded = new NotNeededPackage("google-cloud__pubsub", "@google-cloud/chubdub", "0.26.0");
-    const s = createNotNeededPackageJSON(scopedUnneeded);
+    const s = createNotNeededPackageJSON(scopedUnneeded, "0.26.0");
     expect(s).toEqual(`{
     "name": "@types/google-cloud__pubsub",
     "version": "0.26.0",