Move skipBadPublishes() -> calculate-versions

Author: jablko

__mocks__/pacote.ts

@@ -19,3 +19,15 @@ export async function manifest(spec: string) {
   }
   throw new Error(`Unexpected npm registry fetch: ${util.inspect(spec)}`);
 }
+
+export function packument(spec: string) {
+  switch (spec) {
+    case "@types/not-needed": // A not-needed @types package about to be deprecated.
+      return {versions: {"1.0.0": undefined, "1.0.1": undefined}};
+    case "@types/bad-publish": // A not-needed package after a bad publish.
+      return {versions: {"1.0.0": undefined, "1.0.1": undefined, "1.2.3": undefined}};
+    case "@types/already-deprecated": // A successfully deprecated not-needed stub package.
+      return { deprecated: "Contains built-in declarations." };
+  }
+  throw new Error(`Unexpected npm registry fetch: ${util.inspect(spec)}`);
+}

packages/publisher/src/calculate-versions.ts

@@ -11,6 +11,7 @@ import {
 } from "@definitelytyped/utils";
 import { fetchTypesPackageVersionInfo } from "@definitelytyped/retag";
 import * as pacote from "pacote";
+import * as semver from "semver";
 
 if (!module.parent) {
   const log = loggerWithErrors()[0];
@@ -33,7 +34,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;
@@ -64,32 +65,50 @@ async function computeChangedPackages(allPackages: AllPackages, log: LoggerWithE
   });
   log.info("# Computing deprecated packages...");
   const changedNotNeededPackages = await mapDefinedAsync(allPackages.allNotNeeded(), async (pkg) => {
-    if (!(await isAlreadyDeprecated(pkg, log))) {
+    const incipientVersion = await fetchIncipientStubVersion(pkg, log);
+    if (incipientVersion) {
       await pacote.manifest(pkg.libraryName, { cache: defaultCacheDir }).catch((cause) => {
         throw cause.code === "E404"
           ? new Error(`To deprecate '@types/${pkg.name}', '${pkg.libraryName}' must exist on npm.`, { cause })
           : cause;
       });
       log.info(`To be deprecated: ${pkg.name}`);
-      return pkg;
+      return { pkg, version: incipientVersion };
     }
     return undefined;
   });
   return { changedTypings, changedNotNeededPackages };
 }
 
-async function isAlreadyDeprecated(pkg: NotNeededPackage, log: LoggerWithErrors): Promise<unknown> {
-  const offline = await pacote.manifest(pkg.fullNpmName, {
-    cache: defaultCacheDir,
-    fullMetadata: true,
-    preferOffline: true,
-  });
-  if (!offline._cached || offline.deprecated) return offline.deprecated;
-  log.info(`Version info not cached for deprecated package ${pkg.desc}`);
-  const online = await pacote.manifest(pkg.fullNpmName, {
-    cache: defaultCacheDir,
-    fullMetadata: true,
-    preferOnline: true,
-  });
-  return online.deprecated;
+/**
+ * Return the version of the stub @types package we're about to publish and deprecate, if we haven't already deprecated that package.
+ * It's the max of the not-needed version and the max published version + 1, in case we already published a not-needed-versioned stub but failed to deprecate it, for whatever reason.
+ */
+export async function fetchIncipientStubVersion(pkg: NotNeededPackage, log: LoggerWithErrors): Promise<string | false> {
+  const packument = await revalidate();
+  return (
+    !packument.deprecated &&
+    String(
+      semver.maxSatisfying(
+        [pkg.version, semver.inc(semver.maxSatisfying(Object.keys(packument.versions), "*")!, "patch")!],
+        "*"
+      )
+    )
+  );
+
+  async function revalidate() {
+    const offline = await pacote.packument(pkg.fullNpmName, {
+      cache: defaultCacheDir,
+      fullMetadata: true,
+      preferOffline: true,
+    });
+    if (!offline._cached || offline.deprecated) return offline;
+    log.info(`Version info not cached for deprecated package ${pkg.desc}`);
+    const online = await pacote.packument(pkg.fullNpmName, {
+      cache: defaultCacheDir,
+      fullMetadata: true,
+      preferOnline: true,
+    });
+    return online;
+  }
 }

packages/publisher/src/generate-packages.ts

@@ -15,7 +15,6 @@ import {
   logger,
   writeLog,
   writeFile,
-  Logger,
   defaultCacheDir,
   writeTgz,
 } from "@definitelytyped/utils";
@@ -34,7 +33,6 @@ import {
 import * as pacote from "pacote";
 import { readChangedPackages, ChangedPackages } from "./lib/versions";
 import { outputDirectory } from "./util/util";
-import { skipBadPublishes } from "./lib/npm";
 
 const mitLicense = readFileSync(joinPaths(__dirname, "..", "LICENSE"), "utf-8");
 
@@ -68,9 +66,9 @@ export default async function generatePackages(
     log(` * ${pkg.desc}`);
   }
   log("## Generating deprecated packages");
-  for (const pkg of changedPackages.changedNotNeededPackages) {
+  for (const { pkg, version } of changedPackages.changedNotNeededPackages) {
     log(` * ${pkg.libraryName}`);
-    await generateNotNeededPackage(pkg, log);
+    await generateNotNeededPackage(pkg, version);
   }
   await writeLog("package-generator.md", logResult());
 }
@@ -92,12 +90,11 @@ async function generateTypingPackage(
   );
 }
 
-async function generateNotNeededPackage(pkg: NotNeededPackage, log: Logger): Promise<void> {
-  pkg = await skipBadPublishes(pkg, log);
+async function generateNotNeededPackage(pkg: NotNeededPackage, version: string): Promise<void> {
   const info = await pacote.manifest(pkg.libraryName, { cache: defaultCacheDir, fullMetadata: true });
   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> {
@@ -197,10 +194,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

@@ -13,7 +13,6 @@ import {
   NpmPublishClient,
 } from "@definitelytyped/utils";
 import { readChangedPackages, ChangedPackages } from "./lib/versions";
-import { skipBadPublishes } from "./lib/npm";
 import { getSecret, Secret } from "./lib/secrets";
 
 if (!module.parent) {
@@ -24,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
       );
@@ -140,9 +140,8 @@ export default async function publishPackages(
     }
   }
 
-  for (const n of changedPackages.changedNotNeededPackages) {
-    const target = await skipBadPublishes(n, log);
-    await publishNotNeededPackage(client, target, dry, log);
+  for (const { pkg, version } of changedPackages.changedNotNeededPackages) {
+    await publishNotNeededPackage(client, pkg, version, dry, log);
   }
 
   await writeLog("publishing.md", logResult());

packages/publisher/src/publish-packages.ts

@@ -0,0 +1,25 @@
+import { fetchIncipientStubVersion } from "../src/calculate-versions";
+
+const notNeeded = {
+  fullNpmName: "@types/not-needed",
+  version: "1.2.3",
+};
+const badPublish = {
+  fullNpmName: "@types/bad-publish",
+  version: "1.2.3",
+};
+const alreadyDeprecated = {
+  fullNpmName: "@types/already-deprecated",
+};
+
+test("Returns the not-needed version", () => {
+  return expect(fetchIncipientStubVersion(notNeeded as never)).resolves.toBe("1.2.3");
+});
+
+test("Skips bad publishes", () => {
+  return expect(fetchIncipientStubVersion(badPublish as never)).resolves.toBe("1.2.4");
+});
+
+test("Ignores already-deprecated packages", () => {
+  return expect(fetchIncipientStubVersion(alreadyDeprecated as never)).resolves.toBe(false);
+});

packages/publisher/test/calculate-versions.test.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",