Merge pull request #1542 from mittwald/fix/sort-versions-internal

fix: when sorting version numbers, only sort by internal version numbers

Author: martin-helmich

src/commands/app/dependency/update.tsx

@@ -9,8 +9,9 @@ import { assertStatus } from "@mittwald/api-client-commons";
 import { ReactNode } from "react";
 import type { MittwaldAPIV2 } from "@mittwald/api-client";
 import { Success } from "../../../rendering/react/components/Success.js";
-import { Range, SemVer } from "semver";
+import { Range } from "semver";
 import { ProcessRenderer } from "../../../rendering/process/process.js";
+import { compareVersionsBy } from "../../../lib/resources/app/versions.js";
 
 type AppSystemSoftwareUpdatePolicy =
   MittwaldAPIV2.Components.Schemas.AppSystemSoftwareUpdatePolicy;
@@ -140,7 +141,7 @@ export default class Update extends ExecRenderBaseCommand<typeof Update, void> {
       assertStatus(r, 204);
     });
 
-    process.complete(
+    await process.complete(
       <Success>
         The dependencies of this app were successfully updated!
       </Success>,
@@ -167,13 +168,7 @@ export default class Update extends ExecRenderBaseCommand<typeof Update, void> {
       },
     );
 
-    versions.sort((a, b) => {
-      return (
-        new SemVer(a.externalVersion).compare(new SemVer(b.externalVersion)) *
-        -1
-      );
-    });
-
+    versions.sort(compareVersionsBy("internal"));
     return versions;
   }
 

src/commands/app/dependency/versions.ts

@@ -5,8 +5,8 @@ import {
   SorterFunction,
 } from "../../../lib/basecommands/ListBaseCommand.js";
 import { ListColumns } from "../../../rendering/formatter/ListFormatter.js";
-import { SemVer } from "semver";
 import { Args } from "@oclif/core";
+import { compareVersionsBy } from "../../../lib/resources/app/versions.js";
 
 type ResponseItem = Simplify<
   MittwaldAPIV2.Paths.V2SystemSoftwaresSystemSoftwareIdVersions.Get.Responses.$200.Content.ApplicationJson[number]
@@ -32,8 +32,7 @@ export class Versions extends ListBaseCommand<
     ...ListBaseCommand.baseFlags,
   };
 
-  sorter: SorterFunction<ResponseItem> = (a, b) =>
-    new SemVer(a.externalVersion).compare(b.externalVersion);
+  sorter: SorterFunction<ResponseItem> = compareVersionsBy("internal");
 
   public async getData(): Promise<Response> {
     const systemSoftwareName = this.args["systemsoftware"];
@@ -49,9 +48,9 @@ export class Versions extends ListBaseCommand<
       throw new Error(`system software ${systemSoftwareName} not found`);
     }
 
-    return await this.apiClient.app.listSystemsoftwareversions({
+    return this.apiClient.app.listSystemsoftwareversions({
       systemSoftwareId: systemSoftware.id,
-    } as Parameters<typeof this.apiClient.app.listSystemsoftwareversions>[0]);
+    });
   }
 
   protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem> {

src/lib/resources/app/versions.tsx

@@ -1,13 +1,18 @@
 import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { assertStatus } from "@mittwald/api-client-commons";
-import { gt } from "semver";
+import { coerce, gt } from "semver";
 import { ProcessRenderer } from "../../../rendering/process/process.js";
 import { getAppInstallationFromUuid, getAppNameFromUuid } from "./uuid.js";
 import { compare } from "semver";
 
 type AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
 type AppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
 
+type ObjectWithVersions = {
+  internalVersion: string;
+  externalVersion: string;
+};
+
 export async function normalizeToAppVersionUuid(
   apiClient: MittwaldAPIV2Client,
   version: string,
@@ -142,10 +147,52 @@ export async function getAppVersionUuidFromAppVersion(
   );
 }
 
-export function sortArrayByExternalVersion(
-  versions: AppVersion[],
-): AppVersion[] {
-  return versions.sort((a: AppVersion, b: AppVersion) =>
-    compare(b.externalVersion, a.externalVersion),
-  );
+export function sortArrayByExternalVersion<T extends ObjectWithVersions>(
+  versions: T[],
+): T[] {
+  return versions.sort(compareVersionsBy("external"));
+}
+
+export function sortArrayByInternalVersion<T extends ObjectWithVersions>(
+  versions: T[],
+): T[] {
+  return versions.sort(compareVersionsBy("internal"));
+}
+
+export function compareVersionsBy<T extends ObjectWithVersions>(
+  field: "internal" | "external",
+): (a: T, b: T) => -1 | 0 | 1 {
+  const fullField = `${field}Version` as const;
+  return (a, b) => {
+    const aCoerced = coerce(a[fullField]);
+    const bCoerced = coerce(b[fullField]);
+
+    if (!aCoerced || !bCoerced) {
+      return naiveVersionCompare(a.internalVersion, b.internalVersion);
+    }
+
+    return compare(aCoerced, bCoerced);
+  };
+}
+
+/**
+ * A naive version comparison function that compares version strings in the
+ * format "x.y.z". This function does not handle pre-release or build metadata.
+ */
+function naiveVersionCompare(a: string, b: string): -1 | 0 | 1 {
+  const aParts = a.split(".").map((part) => parseInt(part, 10));
+  const bParts = b.split(".").map((part) => parseInt(part, 10));
+
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+    const aPart = aParts[i] || 0;
+    const bPart = bParts[i] || 0;
+
+    if (aPart > bPart) {
+      return 1;
+    }
+    if (aPart < bPart) {
+      return -1;
+    }
+  }
+  return 0;
 }