Registry API no longer needs %2f-encoding

Author: jablko

packages/definitions-parser/src/packages.ts

@@ -227,11 +227,6 @@ export abstract class PackageBase {
     return getFullNpmName(this.name);
   }
 
-  /** '@types%2ffoo' for a package 'foo'. */
-  get fullEscapedNpmName(): string {
-    return `@${scopeName}%2f${this.name}`;
-  }
-
   abstract readonly major: number;
   abstract readonly minor: number;
 

packages/definitions-parser/test/packages.test.ts

@@ -190,12 +190,6 @@ describe(TypingsData, () => {
       expect(data.fullNpmName).toBe("@types/foo__bar");
     });
   });
-
-  describe("fullEscapedNpmName", () => {
-    it("returns escaped name", () => {
-      expect(data.fullEscapedNpmName).toBe("@types%2fknown");
-    });
-  });
 });
 
 describe(getMangledNameForScopedPackage, () => {

packages/publisher/src/calculate-versions.ts

@@ -98,12 +98,12 @@ async function isAlreadyDeprecated(
   client: CachedNpmInfoClient,
   log: LoggerWithErrors
 ): Promise<boolean> {
-  const cachedInfo = client.getNpmInfoFromCache(pkg.fullEscapedNpmName);
+  const cachedInfo = client.getNpmInfoFromCache(pkg.fullNpmName);
   let latestVersion = cachedInfo && assertDefined(cachedInfo.distTags.get("latest"));
   let latestVersionInfo = cachedInfo && latestVersion && assertDefined(cachedInfo.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));
+    const info = assertDefined(await client.fetchAndCacheNpmInfo(pkg.fullNpmName));
     latestVersion = assertDefined(info.distTags.get("latest"));
     latestVersionInfo = assertDefined(info.versions.get(latestVersion));
   }

packages/publisher/src/lib/npm.ts

@@ -9,7 +9,7 @@ import * as semver from "semver";
  */
 export function skipBadPublishes(pkg: NotNeededPackage, client: CachedNpmInfoClient, 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.fullEscapedNpmName));
+  const info = assertDefined(client.getNpmInfoFromCache(pkg.fullNpmName));
   const notNeeded = pkg.version;
   const latest = new semver.SemVer(findActualLatest(info.time));
   if (semver.lte(notNeeded, latest)) {

packages/publisher/src/publish-registry.ts

@@ -253,11 +253,9 @@ async function generateRegistry(typings: readonly TypingsData[], client: CachedN
   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.fullEscapedNpmName);
+    const info = client.getNpmInfoFromCache(typing.fullNpmName);
     if (!info) {
-      const missings = typings
-        .filter((t) => !client.getNpmInfoFromCache(t.fullEscapedNpmName))
-        .map((t) => t.fullEscapedNpmName);
+      const missings = typings.filter((t) => !client.getNpmInfoFromCache(t.fullNpmName)).map((t) => t.fullNpmName);
       throw new Error(`${missings.toString()} not found in cached npm info.`);
     }
     entries[typing.name] = filterTags(info.distTags);
@@ -284,11 +282,8 @@ interface ProcessedNpmInfo {
   readonly lastModified: Date;
 }
 
-async function fetchAndProcessNpmInfo(
-  escapedPackageName: string,
-  client: UncachedNpmInfoClient
-): Promise<ProcessedNpmInfo> {
-  const info = assertDefined(await client.fetchNpmInfo(escapedPackageName));
+async function fetchAndProcessNpmInfo(packageName: string, client: UncachedNpmInfoClient): Promise<ProcessedNpmInfo> {
+  const info = assertDefined(await client.fetchNpmInfo(packageName));
   const npmVersion = new semver.SemVer(assertDefined(info.distTags.get("latest")));
   const { distTags, versions, time } = info;
   const highestSemverVersion = max(

packages/retag/src/index.ts

@@ -124,14 +124,14 @@ export async function fetchTypesPackageVersionInfo(
   canPublish: boolean,
   log?: LoggerWithErrors
 ): Promise<{ version: string; needsPublish: boolean }> {
-  let info = client.getNpmInfoFromCache(pkg.fullEscapedNpmName);
+  let info = client.getNpmInfoFromCache(pkg.fullNpmName);
   let latestVersion = info && getHighestVersionForMajor(info.versions, pkg);
   let latestVersionInfo = latestVersion && assertDefined(info!.versions.get(latestVersion));
   if (!latestVersionInfo || latestVersionInfo.typesPublisherContentHash !== pkg.contentHash) {
     if (log) {
       log.info(`Version info not cached for ${pkg.desc}@${latestVersion || "(no latest version)"}`);
     }
-    info = await client.fetchAndCacheNpmInfo(pkg.fullEscapedNpmName);
+    info = await client.fetchAndCacheNpmInfo(pkg.fullNpmName);
     latestVersion = info && getHighestVersionForMajor(info.versions, pkg);
     if (!latestVersion) {
       return { version: `${pkg.major}.${pkg.minor}.0`, needsPublish: true };

packages/utils/src/npm.ts

@@ -44,8 +44,8 @@ export interface NpmInfoVersion {
 }
 
 export interface CachedNpmInfoClient {
-  getNpmInfoFromCache(escapedPackageName: string): NpmInfo | undefined;
-  fetchAndCacheNpmInfo(escapedPackageName: string): Promise<NpmInfo | undefined>;
+  getNpmInfoFromCache(packageName: string): NpmInfo | undefined;
+  fetchAndCacheNpmInfo(packageName: string): Promise<NpmInfo | undefined>;
 }
 
 export async function withNpmCache<T>(
@@ -75,15 +75,15 @@ export async function withNpmCache<T>(
   return res;
 
   /** May return old info -- caller should check that this looks up-to-date. */
-  function getNpmInfoFromCache(escapedPackageName: string): NpmInfo | undefined {
-    return unroll.get(escapedPackageName);
+  function getNpmInfoFromCache(packageName: string): NpmInfo | undefined {
+    return unroll.get(packageName);
   }
 
   /** Call this when the result of getNpmInfoFromCache looks potentially out-of-date. */
-  async function fetchAndCacheNpmInfo(escapedPackageName: string): Promise<NpmInfo | undefined> {
-    const info = await uncachedClient.fetchNpmInfo(escapedPackageName);
+  async function fetchAndCacheNpmInfo(packageName: string): Promise<NpmInfo | undefined> {
+    const info = await uncachedClient.fetchNpmInfo(packageName);
     if (info) {
-      unroll.set(escapedPackageName, info);
+      unroll.set(packageName, info);
     }
     return info;
   }
@@ -92,23 +92,23 @@ export async function withNpmCache<T>(
 export class UncachedNpmInfoClient {
   private readonly fetcher = new Fetcher();
 
-  async fetchNpmInfo(escapedPackageName: string): Promise<NpmInfo | undefined> {
-    const raw = await this.fetchRawNpmInfo(escapedPackageName);
+  async fetchNpmInfo(packageName: string): Promise<NpmInfo | undefined> {
+    const raw = await this.fetchRawNpmInfo(packageName);
     await sleep(0.01); // If we don't do this, npm resets the connection?
     return raw === undefined ? undefined : npmInfoFromJson(raw);
   }
 
-  async fetchRawNpmInfo(escapedPackageName: string): Promise<NpmInfoRaw | undefined> {
+  async fetchRawNpmInfo(packageName: string): Promise<NpmInfoRaw | undefined> {
     const info = (await this.fetcher.fetchJson({
       hostname: npmRegistryHostName,
-      path: escapedPackageName,
+      path: packageName,
       retries: true,
     })) as { readonly error: string } | NpmInfoRaw;
     if ("error" in info) {
       if (info.error === "Not found") {
         return undefined;
       }
-      throw new Error(`Error getting version at ${escapedPackageName}: ${info.error}`);
+      throw new Error(`Error getting version at ${packageName}: ${info.error}`);
     }
     if (!info["dist-tags"] && !info.versions) {
       // Unpublished
@@ -205,7 +205,7 @@ export class NpmPublishClient {
   }
 
   deprecate(packageName: string, version: string, message: string): Promise<void> {
-    const url = resolveUrl(npmRegistry, packageName.replace("/", "%2f"));
+    const url = resolveUrl(npmRegistry, packageName);
     const params = {
       message,
       version,